DefinitelyTyped/types/dojo/dojox.dgauges.d.ts

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





declare namespace dojox {

    namespace dgauges {
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/CircularRangeIndicator.html
         *
         * A CircularRangeIndicator is used to represent a range of values on a scale.
         * Use the addIndicator method of CircularScale to use it.
         * It is represented as a donut slice.
         *
         */
        class CircularRangeIndicator extends dojox.dgauges.ScaleIndicatorBase {
            constructor();
            /**
             * The duration of the value change animation in milliseconds. Default is 0.
             * The animation occurs on both user interactions and programmatic value changes.
             * Set this property to 0 to disable animation.
             *
             */
            "animationDuration": number;
            set(property:"animationDuration", value: number): void;
            get(property:"animationDuration"): number;
            watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The easer function of the value change animation. Default is fx._defaultEasing.
             *
             */
            "animationEaser": Object;
            set(property:"animationEaser", value: Object): void;
            get(property:"animationEaser"): Object;
            watch(property:"animationEaser", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The end thickness of the donut slice in pixels.
             *
             */
            "endThickness": number;
            set(property:"endThickness", value: number): void;
            get(property:"endThickness"): number;
            watch(property:"endThickness", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * A fill object that will be passed to the setFill method of GFX.
             *
             */
            "fill": Object;
            set(property:"fill", value: Object): void;
            get(property:"fill"): Object;
            watch(property:"fill", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * How to interact with the indicator using mouse or touch interactions.
             * Can be "indicator", "gauge", "area" or "none". The default value is "gauge".
             * If set to "indicator", the indicator shape reacts to mouse and touch events.
             * If set to "gauge", the whole gauge reacts to mouse and touch events.
             * If set to "area", the whole bounding box of the widget reacts to mouse and touch events.
             * If "none", interactions are disabled.
             *
             */
            "interactionArea": string;
            set(property:"interactionArea", value: string): void;
            get(property:"interactionArea"): string;
            watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Deprecated. Can be "mouse" or "touch".
             *
             */
            "interactionMode": string;
            set(property:"interactionMode", value: string): void;
            get(property:"interactionMode"): string;
            watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The outer radius in pixels of the range indicator.
             *
             */
            "radius": number;
            set(property:"radius", value: number): void;
            get(property:"radius"): number;
            watch(property:"radius", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "scale": Object;
            set(property:"scale", value: Object): void;
            get(property:"scale"): Object;
            watch(property:"scale", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The start value of the range indicator.
             *
             */
            "start": number;
            set(property:"start", value: number): void;
            get(property:"start"): number;
            watch(property:"start", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The start thickness of the donut slice in pixels.
             *
             */
            "startThickness": number;
            set(property:"startThickness", value: number): void;
            get(property:"startThickness"): number;
            watch(property:"startThickness", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * A stroke object that will be passed to the setStroke method of GFX.
             *
             */
            "stroke": Object;
            set(property:"stroke", value: Object): void;
            get(property:"stroke"): Object;
            watch(property:"stroke", callback:{(property?:string, oldValue?:Object, newValue?: Object):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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Invoked when the value of the indicator changes.
             * User can connect an listener on this function:
             *
             * theIndicator.on("valueChanged", lang.hitch(this, function(){
             *     //do something
             * }));
             *
             * @param indicator
             */
            valueChanged(indicator: any): 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/dojox/dgauges/CircularScale.html
         *
         * The circular scale. A scaler must be set to use this class.
         *
         */
        class CircularScale extends dojox.dgauges.ScaleBase {
            constructor();
            /**
             * The end angle of the scale in degrees.
             *
             */
            "endAngle": number;
            set(property:"endAngle", value: number): void;
            get(property:"endAngle"): number;
            watch(property:"endAngle", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The font used for the ticks labels.
             * This is null by default which means this scale use the font defined
             * on the gauge.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The label gap between the ticks and their labels. Default value is 1.
             *
             */
            "labelGap": number;
            set(property:"labelGap", value: number): void;
            get(property:"labelGap"): number;
            watch(property:"labelGap", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * See CircularScale and RectangularScale for valid values.
             *
             */
            "labelPosition": string;
            set(property:"labelPosition", value: string): void;
            get(property:"labelPosition"): string;
            watch(property:"labelPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The orientation of the scale. Can be "clockwise" or "cclockwise".
             * The default value is "clockwise".
             *
             */
            "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 origin x-coordinate of the scale in pixels.
             *
             */
            "originX": number;
            set(property:"originX", value: number): void;
            get(property:"originX"): number;
            watch(property:"originX", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The origin y-coordinate of the scale in pixels.
             *
             */
            "originY": number;
            set(property:"originY", value: number): void;
            get(property:"originY"): number;
            watch(property:"originY", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The outer radius in pixels of the scale.
             *
             */
            "radius": number;
            set(property:"radius", value: number): void;
            get(property:"radius"): number;
            watch(property:"radius", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The scaler used for tick generation and data-transform operations.
             * This property is mandatory for using the scale.
             *
             */
            "scaler": Object;
            set(property:"scaler", value: Object): void;
            get(property:"scaler"): Object;
            watch(property:"scaler", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The start angle of the scale in degrees.
             *
             */
            "startAngle": number;
            set(property:"startAngle", value: number): void;
            get(property:"startAngle"): number;
            watch(property:"startAngle", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The GFX stroke used by the default tickShapeFunc implementation.
             *
             */
            "tickStroke": Object;
            set(property:"tickStroke", value: Object): void;
            get(property:"tickStroke"): Object;
            watch(property:"tickStroke", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Add an indicator to the scale. Before calling this function, ensure
             * this scale has already been added to a gauge using the addElement method
             * of the gauge.
             *
             * @param name The name of the indicator to be added.
             * @param indicator The indicator to add to this scale.
             * @param behindScale If true, this indicator is drawn behind the scale. Default value is false.
             */
            addIndicator(name: String, indicator: dojox.dgauges.IndicatorBase, behindScale: boolean): any;
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Get an indicator instance.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            getIndicator(name: String): any;
            /**
             * Gets the GFX shape of an indicator.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            getIndicatorRenderer(name: String): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             * Transforms a value into an angle using the associated scaler.
             *
             * @param value
             */
            positionForValue(value: number): any;
            /**
             * Returns true if the value parameter is between the accepted scale positions.
             *
             * @param value
             */
            positionInRange(value: number): any;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Removes an indicator.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            removeIndicator(name: String): any;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Customize the text of ticks labels.
             *
             * @param tickItem An object containing the tick informations.
             */
            tickLabelFunc(tickItem: Object): any;
            /**
             * Customize the shape of ticks.
             *
             * @param group The GFX group used for drawing the tick.
             * @param scale The scale being processed.
             * @param tickItem An object containing the tick informations.
             */
            tickShapeFunc(group: dojox.gfx.Group, scale: dojox.dgauges.ScaleBase, tickItem: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Transforms an angle in degrees into a value using the associated scaler.
             *
             * @param angle
             */
            valueForPosition(angle: number): 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};
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/CircularGauge.html
         *
         * The base class for circular gauges.
         * You can create custom circular or semi-circular gauges by extending this class.
         * See dojox.dgauges.components.default.CircularLinearGauge.js for an example of circular gauge.
         *
         * @param args
         * @param node
         */
        class CircularGauge extends dojox.dgauges.GaugeBase {
            constructor(args: Object, node: 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}
            /**
             * The font of the gauge used by elements if not overridden.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", 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}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", 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 property acts as a top-level wrapper for the value of the first indicator added to
             * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
             * This property must be manipulated with get("value") and set("value", xxx).
             *
             */
            "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}
            /**
             * Adds a element to the gauge.
             *
             * @param name The name of the element to be added.
             * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
             */
            addElement(name: String, element: Object): any;
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): 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;
            /**
             * Cleanup when a gauge is to be destroyed.
             *
             */
            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[];
            /**
             * Get the given element, by name.
             *
             * @param name The name of the element as defined using addElement.
             */
            getElement(name: String): any;
            /**
             * Get the given element renderer, by name.
             *
             * @param name The name of the element as defined using addElement.
             */
            getElementRenderer(name: String): any;
            /**
             * Returns the parent widget of this widget.
             *
             */
            getParent(): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): 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;
            /**
             * 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;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Remove the element defined by name from the gauge.
             *
             * @param name The name of the element as defined using addElement.
             */
            removeElement(name: String): any;
            /**
             * Resize the gauge to the dimensions of width and height.
             * Resize the gauge and its surface to the width and height dimensions.
             * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
             * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
             *
             * @param width               OptionalThe new width of the gauge or the box definition.
             * @param height               OptionalThe new height of the gauge.
             */
            resize(width: number, height: number): any;
            /**
             * Resize the gauge to the dimensions of width and height.
             * Resize the gauge and its surface to the width and height dimensions.
             * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
             * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
             *
             * @param width               OptionalThe new width of the gauge or the box definition.
             * @param height               OptionalThe new height of the gauge.
             */
            resize(width: Object, height: 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;
            /**
             * 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;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
             *
             * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
             */
            onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
             *
             * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
             */
            onStartEditing(event: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/CircularValueIndicator.html
         *
         * The circular value indicator, typically used for creating needles.
         *
         */
        class CircularValueIndicator extends dojox.dgauges.ScaleIndicatorBase {
            constructor();
            /**
             * The duration of the value change animation in milliseconds. Default is 0.
             * The animation occurs on both user interactions and programmatic value changes.
             * Set this property to 0 to disable animation.
             *
             */
            "animationDuration": number;
            set(property:"animationDuration", value: number): void;
            get(property:"animationDuration"): number;
            watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The easer function of the value change animation. Default is fx._defaultEasing.
             *
             */
            "animationEaser": Object;
            set(property:"animationEaser", value: Object): void;
            get(property:"animationEaser"): Object;
            watch(property:"animationEaser", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * How to interact with the indicator using mouse or touch interactions.
             * Can be "indicator", "gauge", "area" or "none". The default value is "gauge".
             * If set to "indicator", the indicator shape reacts to mouse and touch events.
             * If set to "gauge", the whole gauge reacts to mouse and touch events.
             * If set to "area", the whole bounding box of the widget reacts to mouse and touch events.
             * If "none", interactions are disabled.
             *
             */
            "interactionArea": string;
            set(property:"interactionArea", value: string): void;
            get(property:"interactionArea"): string;
            watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Deprecated. Can be "mouse" or "touch".
             *
             */
            "interactionMode": string;
            set(property:"interactionMode", value: string): void;
            get(property:"interactionMode"): string;
            watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             *
             */
            "scale": Object;
            set(property:"scale", value: Object): void;
            get(property:"scale"): Object;
            watch(property:"scale", callback:{(property?:string, oldValue?:Object, newValue?: Object):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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Draws the indicator. The rotation center is at (0, 0).
             *
             * @param group A GFX group for drawing.
             * @param indicator A reference to this indicator.
             */
            indicatorShapeFunc(group: dojox.gfx.Group, indicator: dojox.dgauges.IndicatorBase): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Invoked when the value of the indicator changes.
             * User can connect an listener on this function:
             *
             * theIndicator.on("valueChanged", lang.hitch(this, function(){
             *     //do something
             * }));
             *
             * @param indicator
             */
            valueChanged(indicator: any): 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/dojox/dgauges/IndicatorBase.html
         *
         * The base class for indicators. Basically, an indicator is used to render a value.
         *
         */
        class IndicatorBase extends dojox.widget._Invalidating {
            constructor();
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The value of this indicator.
             *
             */
            "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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             * Actually refresh the rendering. Implementation should implement that method.
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): 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/dojox/dgauges/LogScaler.html
         *
         * The LogScaler maps numeric values evenly
         * between a minimum and a maximum value along a gauge scale.
         * If no multiplier is specified, the scale will place
         * a tick on each power of 10 value (1, 10, 100, 1000, and so on) between
         * the minimum and maximum values.
         *
         */
        class LogScaler extends dojo.Stateful {
            constructor();
            /**
             * The array of generated major ticks. You should not set this
             * property when using the scaler.
             *
             */
            "majorTicks": Object;
            set(property:"majorTicks", value: Object): void;
            get(property:"majorTicks"): Object;
            watch(property:"majorTicks", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The maximum value of the scaler. Default is 1000.
             *
             */
            "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 of the scaler. Default is 0.
             *
             */
            "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}
            /**
             * The interval between two major ticks.
             *
             */
            "multiplier": number;
            set(property:"multiplier", value: number): void;
            get(property:"multiplier"): number;
            watch(property:"multiplier", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Creates or re-creates the ticks for this scaler.
             *
             */
            computeTicks(): any;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * The computed maximum value of the scale. If the maximum value is not
             * an even power of 10, the scale computes a new maximum so that it maps to
             * an even power of 10.
             *
             */
            getComputedMaximum(): any;
            /**
             * The computed minimum value of the scale. If the minimum value is not
             * an even power of 10, the scale computes a new minimum so that it maps to
             * an even power of 10.
             *
             */
            getComputedMinimum(): any;
            /**
             * The computed multiplier value of the scale. If the multiplier value is not
             * an even power of 10, the scale computes a new multiplier so that it maps to
             * an even power of 10.
             *
             */
            getComputedMultiplier(): any;
            /**
             * Transforms a value into a relative position between 0 and 1.
             *
             * @param value A value to transform.
             */
            positionForValue(value: number): any;
            /**
             *
             * @param params               Optional
             */
            postscript(params: Object): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Transforms a relative position (between 0 and 1) into a value.
             *
             * @param position A relative position to transform.
             */
            valueForPosition(position: number): 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};
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/MultiLinearScaler.html
         *
         * The multi-linear scaler. This scaler maps numeric values according
         * to the majorTickValues content.
         * This allows display of very large value intervals that are difficult to render
         * with a linear scale. For example, if majorTickValues contains [0, 10, 50, 500, 2000],
         * the scale will show five major ticks with these values.
         * Note that this is not a logarithmic scale, the interpolation is linear between
         * two contiguous major ticks.
         * Scalers are responsible for tick generation and various data-transform operations.
         *
         */
        class MultiLinearScaler extends dojo.Stateful {
            constructor();
            /**
             * The array of generated major ticks. You should not set this
             * property when using the scaler.
             *
             */
            "majorTicks": Object;
            set(property:"majorTicks", value: Object): void;
            get(property:"majorTicks"): Object;
            watch(property:"majorTicks", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * An array of Number for creating major ticks.
             * This array must be sorted in ascendant order.
             *
             */
            "majorTickValues": any[];
            set(property:"majorTickValues", value: any[]): void;
            get(property:"majorTickValues"): any[];
            watch(property:"majorTickValues", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
            /**
             * The number of minor ticks between two contiguous major ticks.
             * The default value is 4.
             *
             */
            "minorTickCount": any[];
            set(property:"minorTickCount", value: any[]): void;
            get(property:"minorTickCount"): any[];
            watch(property:"minorTickCount", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
            /**
             * The array of generated minor ticks. You should not set this
             * property when using the scaler.
             *
             */
            "minorTicks": Object;
            set(property:"minorTicks", value: Object): void;
            get(property:"minorTicks"): Object;
            watch(property:"minorTicks", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Creates or re-creates the ticks for this scaler.
             *
             */
            computeTicks(): any;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Transforms a value into a relative position between 0 and 1.
             *
             * @param value A value to transform.
             */
            positionForValue(value: number): any;
            /**
             *
             * @param params               Optional
             */
            postscript(params: Object): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Transforms a relative position (between 0 and 1) into a value.
             *
             * @param position A relative position to transform.
             */
            valueForPosition(position: number): 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};
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/LinearScaler.html
         *
         * The linear scaler. This scaler creates major and minor ticks regularly between
         * a minimum and a maximum.
         * Scalers are responsible for tick generation and various data-transform operations.
         *
         */
        class LinearScaler extends dojo.Stateful {
            constructor();
            /**
             * The interval between two major ticks.
             *
             */
            "majorTickInterval": number;
            set(property:"majorTickInterval", value: number): void;
            get(property:"majorTickInterval"): number;
            watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The array of generated major ticks. You should not set this
             * property when using the scaler.
             *
             */
            "majorTicks": Object;
            set(property:"majorTicks", value: Object): void;
            get(property:"majorTicks"): Object;
            watch(property:"majorTicks", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The maximum value of the scaler. Default is 100.
             *
             */
            "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 of the scaler. Default is 0.
             *
             */
            "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}
            /**
             * The interval between two minor ticks.
             *
             */
            "minorTickInterval": number;
            set(property:"minorTickInterval", value: number): void;
            get(property:"minorTickInterval"): number;
            watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The array of generated minor ticks. You should not set this
             * property when using the scaler.
             *
             */
            "minorTicks": Object;
            set(property:"minorTicks", value: Object): void;
            get(property:"minorTicks"): Object;
            watch(property:"minorTicks", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * If false, minor ticks are not generated. Default is true.
             *
             */
            "minorTicksEnabled": boolean;
            set(property:"minorTicksEnabled", value: boolean): void;
            get(property:"minorTicksEnabled"): boolean;
            watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * Specifies the increment value to be used as snap values on this scale
             * during user interaction.
             * Default is 1.
             *
             */
            "snapInterval": number;
            set(property:"snapInterval", value: number): void;
            get(property:"snapInterval"): number;
            watch(property:"snapInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Creates or re-creates the ticks for this scaler.
             *
             */
            computeTicks(): any;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * The computed or user defined major tick interval.
             *
             */
            getComputedMajorTickInterval(): any;
            /**
             * The computed or user defined minor tick interval.
             *
             */
            getComputedMinorTickInterval(): any;
            /**
             * Transforms a value into a relative position between 0 and 1.
             *
             * @param value A value to transform.
             */
            positionForValue(value: number): any;
            /**
             *
             * @param params               Optional
             */
            postscript(params: Object): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Transforms a relative position (between 0 and 1) into a value.
             *
             * @param position A relative position to transform.
             */
            valueForPosition(position: number): 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};
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/GaugeBase.html
         *
         * This class is the base class for the circular and
         * rectangular (horizontal and vertical) gauge components.
         * A gauge is a composition of elements added to the gauge using the addElement method.
         * Elements are drawn from back to front in the same order they are added (using addElement).
         * An elements can be:
         *
         * A GFX drawing functions typically used for defining the style of the gauge.
         * A scale: CircularScale or RectangularScale depending on the type of gauge.
         * A text, using the TextIndicator
         * Note: Indicator classes (value indicators, range indicators) are sub-elements of scales
         * To create a custom gauge, subclass CircularGauge or RectangularGauge and
         * configure its elements in the constructor.
         * Ready to use, predefined gauges are available in dojox/dgauges/components/
         * They are good examples of gauges built on top of the framework.
         *
         * @param args
         * @param node
         */
        class GaugeBase extends dijit._WidgetBase implements dojox.widget._Invalidating {
            constructor(args: Object, node: 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}
            /**
             * The font of the gauge used by elements if not overridden.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", 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}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", 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 property acts as a top-level wrapper for the value of the first indicator added to
             * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
             * This property must be manipulated with get("value") and set("value", xxx).
             *
             */
            "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}
            /**
             * Adds a element to the gauge.
             *
             * @param name The name of the element to be added.
             * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
             */
            addElement(name: String, element: Object): any;
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): 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;
            /**
             * Cleanup when a gauge is to be destroyed.
             *
             */
            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[];
            /**
             * Get the given element, by name.
             *
             * @param name The name of the element as defined using addElement.
             */
            getElement(name: String): any;
            /**
             * Get the given element renderer, by name.
             *
             * @param name The name of the element as defined using addElement.
             */
            getElementRenderer(name: String): any;
            /**
             * Returns the parent widget of this widget.
             *
             */
            getParent(): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): 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;
            /**
             * 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;
            /**
             * Actually refresh the rendering. Implementation should implement that method.
             *
             */
            refreshRendering(): void;
            /**
             * Remove the element defined by name from the gauge.
             *
             * @param name The name of the element as defined using addElement.
             */
            removeElement(name: String): any;
            /**
             * Resize the gauge to the dimensions of width and height.
             * Resize the gauge and its surface to the width and height dimensions.
             * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
             * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
             *
             * @param width               OptionalThe new width of the gauge or the box definition.
             * @param height               OptionalThe new height of the gauge.
             */
            resize(width: number, height: number): any;
            /**
             * Resize the gauge to the dimensions of width and height.
             * Resize the gauge and its surface to the width and height dimensions.
             * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
             * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
             *
             * @param width               OptionalThe new width of the gauge or the box definition.
             * @param height               OptionalThe new height of the gauge.
             */
            resize(width: Object, height: 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;
            /**
             * 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;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
             *
             * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
             */
            onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
             *
             * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
             */
            onStartEditing(event: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/RectangularSegmentedRangeIndicator.html
         *
         * A segmented-style range indicator for rectangular gauges.
         * This class will be replaced by a cleaner implementation in a future version.
         *
         */
        class RectangularSegmentedRangeIndicator extends dojox.dgauges.IndicatorBase {
            constructor();
            /**
             *
             */
            "endThickness": number;
            set(property:"endThickness", value: number): void;
            get(property:"endThickness"): number;
            watch(property:"endThickness", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "fill": Object;
            set(property:"fill", value: Object): void;
            get(property:"fill"): Object;
            watch(property:"fill", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             *
             */
            "paddingBottom": number;
            set(property:"paddingBottom", value: number): void;
            get(property:"paddingBottom"): number;
            watch(property:"paddingBottom", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "paddingLeft": number;
            set(property:"paddingLeft", value: number): void;
            get(property:"paddingLeft"): number;
            watch(property:"paddingLeft", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "paddingRight": number;
            set(property:"paddingRight", value: number): void;
            get(property:"paddingRight"): number;
            watch(property:"paddingRight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "paddingTop": number;
            set(property:"paddingTop", value: number): void;
            get(property:"paddingTop"): number;
            watch(property:"paddingTop", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * An array containing objects to define color ranges. Example [{color:"#FF0000", size:20}, {color:"#FF8800", size:50}].
             *
             */
            "ranges": any[];
            set(property:"ranges", value: any[]): void;
            get(property:"ranges"): any[];
            watch(property:"ranges", callback:{(property?:string, oldValue?:any[], newValue?: any[]):void}) :{unwatch():void}
            /**
             * Indicates if the extremity segments are rounded.
             * Default is true.
             *
             */
            "rounded": boolean;
            set(property:"rounded", value: boolean): void;
            get(property:"rounded"): boolean;
            watch(property:"rounded", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The number of segments making the indicator.
             * By default it is 10.
             *
             */
            "segments": number;
            set(property:"segments", value: number): void;
            get(property:"segments"): number;
            watch(property:"segments", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The blank space between two segments. The default value is 2
             *
             */
            "segmentSpacing": number;
            set(property:"segmentSpacing", value: number): void;
            get(property:"segmentSpacing"): number;
            watch(property:"segmentSpacing", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "start": number;
            set(property:"start", value: number): void;
            get(property:"start"): number;
            watch(property:"start", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "startThickness": number;
            set(property:"startThickness", value: number): void;
            get(property:"startThickness"): number;
            watch(property:"startThickness", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "stroke": Object;
            set(property:"stroke", value: Object): void;
            get(property:"stroke"): Object;
            watch(property:"stroke", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The value of this indicator.
             *
             */
            "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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): 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/dojox/dgauges/ScaleBase.html
         *
         * The ScaleBase class is the base class for the circular and rectangular scales.
         * A scaler must be set to use this class. A scaler is responsible for
         * tick generation and various data-transform operations.
         *
         */
        class ScaleBase extends dojox.widget._Invalidating {
            constructor();
            /**
             * The font used for the ticks labels.
             * This is null by default which means this scale use the font defined
             * on the gauge.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The label gap between the ticks and their labels. Default value is 1.
             *
             */
            "labelGap": number;
            set(property:"labelGap", value: number): void;
            get(property:"labelGap"): number;
            watch(property:"labelGap", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * See CircularScale and RectangularScale for valid values.
             *
             */
            "labelPosition": string;
            set(property:"labelPosition", value: string): void;
            get(property:"labelPosition"): string;
            watch(property:"labelPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The scaler used for tick generation and data-transform operations.
             * This property is mandatory for using the scale.
             *
             */
            "scaler": Object;
            set(property:"scaler", value: Object): void;
            get(property:"scaler"): Object;
            watch(property:"scaler", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The GFX stroke used by the default tickShapeFunc implementation.
             *
             */
            "tickStroke": Object;
            set(property:"tickStroke", value: Object): void;
            get(property:"tickStroke"): Object;
            watch(property:"tickStroke", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Add an indicator to the scale. Before calling this function, ensure
             * this scale has already been added to a gauge using the addElement method
             * of the gauge.
             *
             * @param name The name of the indicator to be added.
             * @param indicator The indicator to add to this scale.
             * @param behindScale If true, this indicator is drawn behind the scale. Default value is false.
             */
            addIndicator(name: String, indicator: dojox.dgauges.IndicatorBase, behindScale: boolean): any;
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Get an indicator instance.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            getIndicator(name: String): any;
            /**
             * Gets the GFX shape of an indicator.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            getIndicatorRenderer(name: String): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             * See CircularScale and Rectangular for more informations.
             *
             * @param value The value to convert.
             */
            positionForValue(value: number): any;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Removes an indicator.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            removeIndicator(name: String): any;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Customize the text of ticks labels.
             *
             * @param tickItem An object containing the tick informations.
             */
            tickLabelFunc(tickItem: Object): any;
            /**
             * Customize the shape of ticks.
             *
             * @param group The GFX group used for drawing the tick.
             * @param scale The scale being processed.
             * @param tickItem An object containing the tick informations.
             */
            tickShapeFunc(group: dojox.gfx.Group, scale: dojox.dgauges.ScaleBase, tickItem: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * See CircularScale and Rectangular for more informations.
             *
             * @param position The position to convert.
             */
            valueForPosition(position: number): number;
            /**
             * 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/dojox/dgauges/RectangularScale.html
         *
         * The rectangular scale. A scaler must be set to use this class.
         *
         */
        class RectangularScale extends dojox.dgauges.ScaleBase {
            constructor();
            /**
             * The font used for the ticks labels.
             * This is null by default which means this scale use the font defined
             * on the gauge.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The label gap between the ticks and their labels. Default value is 1.
             *
             */
            "labelGap": number;
            set(property:"labelGap", value: number): void;
            get(property:"labelGap"): number;
            watch(property:"labelGap", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * See CircularScale and RectangularScale for valid values.
             *
             */
            "labelPosition": string;
            set(property:"labelPosition", value: string): void;
            get(property:"labelPosition"): string;
            watch(property:"labelPosition", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The bottom padding.
             *
             */
            "paddingBottom": number;
            set(property:"paddingBottom", value: number): void;
            get(property:"paddingBottom"): number;
            watch(property:"paddingBottom", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The left padding.
             *
             */
            "paddingLeft": number;
            set(property:"paddingLeft", value: number): void;
            get(property:"paddingLeft"): number;
            watch(property:"paddingLeft", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The right padding.
             *
             */
            "paddingRight": number;
            set(property:"paddingRight", value: number): void;
            get(property:"paddingRight"): number;
            watch(property:"paddingRight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The top padding.
             *
             */
            "paddingTop": number;
            set(property:"paddingTop", value: number): void;
            get(property:"paddingTop"): number;
            watch(property:"paddingTop", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The scaler used for tick generation and data-transform operations.
             * This property is mandatory for using the scale.
             *
             */
            "scaler": Object;
            set(property:"scaler", value: Object): void;
            get(property:"scaler"): Object;
            watch(property:"scaler", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The GFX stroke used by the default tickShapeFunc implementation.
             *
             */
            "tickStroke": Object;
            set(property:"tickStroke", value: Object): void;
            get(property:"tickStroke"): Object;
            watch(property:"tickStroke", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Add an indicator to the scale. Before calling this function, ensure
             * this scale has already been added to a gauge using the addElement method
             * of the gauge.
             *
             * @param name The name of the indicator to be added.
             * @param indicator The indicator to add to this scale.
             * @param behindScale If true, this indicator is drawn behind the scale. Default value is false.
             */
            addIndicator(name: String, indicator: dojox.dgauges.IndicatorBase, behindScale: boolean): any;
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Get an indicator instance.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            getIndicator(name: String): any;
            /**
             * Gets the GFX shape of an indicator.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            getIndicatorRenderer(name: String): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             * Transforms a value into a position using the associated scaler.
             *
             * @param value The value to transform.
             */
            positionForValue(value: any): any;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Removes an indicator.
             *
             * @param name The name of the indicator as defined using addIndicator.
             */
            removeIndicator(name: String): any;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Customize the text of ticks labels.
             *
             * @param tickItem An object containing the tick informations.
             */
            tickLabelFunc(tickItem: Object): any;
            /**
             * Customize the shape of ticks.
             *
             * @param group The GFX group used for drawing the tick.
             * @param scale The scale being processed.
             * @param tickItem An object containing the tick informations.
             */
            tickShapeFunc(group: dojox.gfx.Group, scale: dojox.dgauges.ScaleBase, tickItem: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Transforms a position in pixels into a value using the associated scaler.
             *
             * @param pos The position to transform.
             */
            valueForPosition(pos: any): 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};
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/RectangularValueIndicator.html
         *
         * The rectangular value indicator, typically used for creating markers or thumbs.
         *
         */
        class RectangularValueIndicator extends dojox.dgauges.ScaleIndicatorBase {
            constructor();
            /**
             * The duration of the value change animation in milliseconds. Default is 0.
             * The animation occurs on both user interactions and programmatic value changes.
             * Set this property to 0 to disable animation.
             *
             */
            "animationDuration": number;
            set(property:"animationDuration", value: number): void;
            get(property:"animationDuration"): number;
            watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The easer function of the value change animation. Default is fx._defaultEasing.
             *
             */
            "animationEaser": Object;
            set(property:"animationEaser", value: Object): void;
            get(property:"animationEaser"): Object;
            watch(property:"animationEaser", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * How to interact with the indicator using mouse or touch interactions.
             * Can be "indicator", "gauge", "area" or "none". The default value is "gauge".
             * If set to "indicator", the indicator shape reacts to mouse and touch events.
             * If set to "gauge", the whole gauge reacts to mouse and touch events.
             * If set to "area", the whole bounding box of the widget reacts to mouse and touch events.
             * If "none", interactions are disabled.
             *
             */
            "interactionArea": string;
            set(property:"interactionArea", value: string): void;
            get(property:"interactionArea"): string;
            watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Deprecated. Can be "mouse" or "touch".
             *
             */
            "interactionMode": string;
            set(property:"interactionMode", value: string): void;
            get(property:"interactionMode"): string;
            watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The bottom padding.
             *
             */
            "paddingBottom": number;
            set(property:"paddingBottom", value: number): void;
            get(property:"paddingBottom"): number;
            watch(property:"paddingBottom", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The left padding.
             *
             */
            "paddingLeft": number;
            set(property:"paddingLeft", value: number): void;
            get(property:"paddingLeft"): number;
            watch(property:"paddingLeft", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The right padding.
             *
             */
            "paddingRight": number;
            set(property:"paddingRight", value: number): void;
            get(property:"paddingRight"): number;
            watch(property:"paddingRight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The top padding.
             *
             */
            "paddingTop": number;
            set(property:"paddingTop", value: number): void;
            get(property:"paddingTop"): number;
            watch(property:"paddingTop", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "scale": Object;
            set(property:"scale", value: Object): void;
            get(property:"scale"): Object;
            watch(property:"scale", callback:{(property?:string, oldValue?:Object, newValue?: Object):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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Draws the indicator.
             *
             * @param group A GFX group for drawing. The indicator is always centered horizontally and isautomatically rotated if the scale is vertical.
             * @param indicator A reference to this indicator.
             */
            indicatorShapeFunc(group: dojox.gfx.Group, indicator: dojox.dgauges.IndicatorBase): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Invoked when the value of the indicator changes.
             * User can connect an listener on this function:
             *
             * theIndicator.on("valueChanged", lang.hitch(this, function(){
             *     //do something
             * }));
             *
             * @param indicator
             */
            valueChanged(indicator: any): 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/dojox/dgauges/RectangularRangeIndicator.html
         *
         * A RectangularRangeIndicator is used to represent a range of values on a scale.
         * For adding this kind of indicator instance to the gauge, use the addIndicator
         * method of RectangularScale.
         *
         */
        class RectangularRangeIndicator extends dojox.dgauges.ScaleIndicatorBase {
            constructor();
            /**
             * The duration of the value change animation in milliseconds. Default is 0.
             * The animation occurs on both user interactions and programmatic value changes.
             * Set this property to 0 to disable animation.
             *
             */
            "animationDuration": number;
            set(property:"animationDuration", value: number): void;
            get(property:"animationDuration"): number;
            watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The easer function of the value change animation. Default is fx._defaultEasing.
             *
             */
            "animationEaser": Object;
            set(property:"animationEaser", value: Object): void;
            get(property:"animationEaser"): Object;
            watch(property:"animationEaser", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The thickness in pixels of the shape at the position defined by the value property.
             * Default is 10.
             *
             */
            "endThickness": number;
            set(property:"endThickness", value: number): void;
            get(property:"endThickness"): number;
            watch(property:"endThickness", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * A fill object that will be passed to the setFill method of GFX.
             *
             */
            "fill": Object;
            set(property:"fill", value: Object): void;
            get(property:"fill"): Object;
            watch(property:"fill", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * How to interact with the indicator using mouse or touch interactions.
             * Can be "indicator", "gauge", "area" or "none". The default value is "gauge".
             * If set to "indicator", the indicator shape reacts to mouse and touch events.
             * If set to "gauge", the whole gauge reacts to mouse and touch events.
             * If set to "area", the whole bounding box of the widget reacts to mouse and touch events.
             * If "none", interactions are disabled.
             *
             */
            "interactionArea": string;
            set(property:"interactionArea", value: string): void;
            get(property:"interactionArea"): string;
            watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Deprecated. Can be "mouse" or "touch".
             *
             */
            "interactionMode": string;
            set(property:"interactionMode", value: string): void;
            get(property:"interactionMode"): string;
            watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * The bottom padding. Not used for vertical gauges.
             *
             */
            "paddingBottom": number;
            set(property:"paddingBottom", value: number): void;
            get(property:"paddingBottom"): number;
            watch(property:"paddingBottom", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The left padding. Not used for horizontal gauges.
             *
             */
            "paddingLeft": number;
            set(property:"paddingLeft", value: number): void;
            get(property:"paddingLeft"): number;
            watch(property:"paddingLeft", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The right padding. Not used for horizontal gauges.
             *
             */
            "paddingRight": number;
            set(property:"paddingRight", value: number): void;
            get(property:"paddingRight"): number;
            watch(property:"paddingRight", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The top padding. Not used for vertical gauges.
             *
             */
            "paddingTop": number;
            set(property:"paddingTop", value: number): void;
            get(property:"paddingTop"): number;
            watch(property:"paddingTop", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             *
             */
            "scale": Object;
            set(property:"scale", value: Object): void;
            get(property:"scale"): Object;
            watch(property:"scale", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The start value of the range. Default is 0.
             *
             */
            "start": number;
            set(property:"start", value: number): void;
            get(property:"start"): number;
            watch(property:"start", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The thickness in pixels of the shape at the position defined by the start property.
             * Default is 10.
             *
             */
            "startThickness": number;
            set(property:"startThickness", value: number): void;
            get(property:"startThickness"): number;
            watch(property:"startThickness", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * A stroke object that will be passed to the setStroke method of GFX.
             *
             */
            "stroke": Object;
            set(property:"stroke", value: Object): void;
            get(property:"stroke"): Object;
            watch(property:"stroke", callback:{(property?:string, oldValue?:Object, newValue?: Object):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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Invoked when the value of the indicator changes.
             * User can connect an listener on this function:
             *
             * theIndicator.on("valueChanged", lang.hitch(this, function(){
             *     //do something
             * }));
             *
             * @param indicator
             */
            valueChanged(indicator: any): 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/dojox/dgauges/TextIndicator.html
         *
         * This type of indicator is used to render text.
         * To render an arbitrary text, set the value property.
         * To render the value of a value indicator or a range indicator, set the indicator property.
         * Setting the indicator property takes precedence on setting the value property.
         * When the indicator property is set, the text is automatically updated on value changes.
         *
         */
        class TextIndicator extends dojox.dgauges.IndicatorBase {
            constructor();
            /**
             * An alignment of a text in regards to the anchor position:
             *
             * "start": A text's baseline starts at the anchor.
             * This is the default value of the align attribute.
             * "middle": A text's baseline is centered on the anchor point.
             * "end": A text's baseline ends at the anchor point.
             *
             */
            "align": string;
            set(property:"align", value: string): void;
            get(property:"align"): string;
            watch(property:"align", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * The color of the text.
             *
             */
            "color": Object;
            set(property:"color", value: Object): void;
            get(property:"color"): Object;
            watch(property:"color", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * Font used by this element.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * If this property is set, the value of the indicator is automatically
             * rendered by this text element.
             *
             */
            "indicator": Object;
            set(property:"indicator", value: Object): void;
            get(property:"indicator"): Object;
            watch(property:"indicator", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             * If set, this method allows to format the value of this text indicator.
             * A label function takes the text to render as argument and returns a String.
             *
             */
            "labelFunc": Object;
            set(property:"labelFunc", value: Object): void;
            get(property:"labelFunc"): Object;
            watch(property:"labelFunc", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * The value of this indicator.
             *
             */
            "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}
            /**
             * The text anchor x-position. Default is 0.
             *
             */
            "x": number;
            set(property:"x", value: number): void;
            get(property:"x"): number;
            watch(property:"x", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The text anchor y-position. Default is 0.
             *
             */
            "y": number;
            set(property:"y", value: number): void;
            get(property:"y"): number;
            watch(property:"y", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             */
            refreshRendering(): any;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): 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/dojox/dgauges/RectangularGauge.html
         *
         * The base class for rectangular gauges.
         * You can create custom horizontal or vertical gauges by extending this class.
         * See dojox/dgauges/components/default/HorinzontalLinearGauge.js for an example of rectangular gauge.
         *
         */
        class RectangularGauge extends dojox.dgauges.GaugeBase {
            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}
            /**
             * 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}
            /**
             * The font of the gauge used by elements if not overridden.
             *
             */
            "font": Object;
            set(property:"font", value: Object): void;
            get(property:"font"): Object;
            watch(property:"font", 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}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", 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 orientation of the gauge. Default is "horizontal".
             *
             */
            "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}
            /**
             * 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 property acts as a top-level wrapper for the value of the first indicator added to
             * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
             * This property must be manipulated with get("value") and set("value", xxx).
             *
             */
            "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}
            /**
             * Adds a element to the gauge.
             *
             * @param name The name of the element to be added.
             * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
             * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
             */
            addElement(name: String, element: Object, location?: String): void;
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): 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;
            /**
             * Cleanup when a gauge is to be destroyed.
             *
             */
            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[];
            /**
             * Get the given element, by name.
             *
             * @param name The name of the element as defined using addElement.
             */
            getElement(name: String): any;
            /**
             * Get the given element renderer, by name.
             *
             * @param name The name of the element as defined using addElement.
             */
            getElementRenderer(name: String): any;
            /**
             * Returns the parent widget of this widget.
             *
             */
            getParent(): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): 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;
            /**
             * 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;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Remove the element defined by name from the gauge.
             *
             * @param name The name of the element as defined using addElement.
             */
            removeElement(name: String): Object;
            /**
             * Resize the gauge to the dimensions of width and height.
             * Resize the gauge and its surface to the width and height dimensions.
             * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
             * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
             *
             * @param width               OptionalThe new width of the gauge or the box definition.
             * @param height               OptionalThe new height of the gauge.
             */
            resize(width: number, height: number): any;
            /**
             * Resize the gauge to the dimensions of width and height.
             * Resize the gauge and its surface to the width and height dimensions.
             * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
             * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
             *
             * @param width               OptionalThe new width of the gauge or the box definition.
             * @param height               OptionalThe new height of the gauge.
             */
            resize(width: Object, height: 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;
            /**
             * 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;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
             *
             * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
             */
            onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
             *
             * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
             */
            onStartEditing(event: any): void;
        }
        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/ScaleIndicatorBase.html
         *
         * The base class for indicators that rely on a scale for their rendering.
         * Typically, value indicators and range indicators are subclasses of ScaleIndicatorBase.
         *
         */
        class ScaleIndicatorBase extends dojox.dgauges.IndicatorBase {
            constructor();
            /**
             * The duration of the value change animation in milliseconds. Default is 0.
             * The animation occurs on both user interactions and programmatic value changes.
             * Set this property to 0 to disable animation.
             *
             */
            "animationDuration": number;
            set(property:"animationDuration", value: number): void;
            get(property:"animationDuration"): number;
            watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
            /**
             * The easer function of the value change animation. Default is fx._defaultEasing.
             *
             */
            "animationEaser": Object;
            set(property:"animationEaser", value: Object): void;
            get(property:"animationEaser"): Object;
            watch(property:"animationEaser", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             * How to interact with the indicator using mouse or touch interactions.
             * Can be "indicator", "gauge", "area" or "none". The default value is "gauge".
             * If set to "indicator", the indicator shape reacts to mouse and touch events.
             * If set to "gauge", the whole gauge reacts to mouse and touch events.
             * If set to "area", the whole bounding box of the widget reacts to mouse and touch events.
             * If "none", interactions are disabled.
             *
             */
            "interactionArea": string;
            set(property:"interactionArea", value: string): void;
            get(property:"interactionArea"): string;
            watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             * Deprecated. Can be "mouse" or "touch".
             *
             */
            "interactionMode": string;
            set(property:"interactionMode", value: string): void;
            get(property:"interactionMode"): string;
            watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
            /**
             *
             */
            "invalidatingProperties": Object;
            set(property:"invalidatingProperties", value: Object): void;
            get(property:"invalidatingProperties"): Object;
            watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
            /**
             *
             */
            "invalidRendering": boolean;
            set(property:"invalidRendering", value: boolean): void;
            get(property:"invalidRendering"): boolean;
            watch(property:"invalidRendering", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
            /**
             *
             */
            "scale": Object;
            set(property:"scale", value: Object): void;
            get(property:"scale"): Object;
            watch(property:"scale", callback:{(property?:string, oldValue?:Object, newValue?: Object):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}
            /**
             * Add properties to the watched properties to trigger invalidation. This method must be called in
             * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
             * to watch for.
             *
             * @param properties The list of properties to watch for.
             */
            addInvalidatingProperties(properties: String[]): void;
            /**
             * Get a property on a Stateful instance.
             * Get a named property on a Stateful object. The property may
             * potentially be retrieved via a getter method in subclasses. In the base class
             * this just retrieves the object's property.
             *
             * @param name The property to get.
             */
            get(name: string): any;
            /**
             * Invalidating the rendering for the next executation frame.
             *
             */
            invalidateRendering(): void;
            /**
             *
             * @param mixin
             */
            postscript(mixin: any): void;
            /**
             *
             */
            refreshRendering(): void;
            /**
             * Set a property on a Stateful instance
             * Sets named properties on a stateful object and notifies any watchers of
             * the property. A programmatic setter may be defined in subclasses.
             *
             * @param name The property to set.
             * @param value The value to set in the property.
             */
            set(name: string, value: Object): any;
            /**
             * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
             *
             */
            validateRendering(): void;
            /**
             * Invoked when the value of the indicator changes.
             * User can connect an listener on this function:
             *
             * theIndicator.on("valueChanged", lang.hitch(this, function(){
             *     //do something
             * }));
             *
             * @param indicator
             */
            valueChanged(indicator: any): 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};
        }
        namespace components {
            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/DefaultPropertiesMixin.html
             *
             * This class defines default properties of predefined gauges.
             *
             */
            class DefaultPropertiesMixin {
                constructor();
                /**
                 * The duration of the value change animation in milliseconds. Default is 0.
                 * The animation occurs on both user interactions and programmatic value changes.
                 * Set this property to 0 to disable animation.
                 *
                 */
                "animationDuration": number;
                /**
                 * How to interact with the indicator using mouse or touch interactions.
                 * Can be "indicator", "gauge" or "none". The default value is "gauge".
                 * If set to "indicator", the indicator shape reacts to mouse and touch events.
                 * If set to "gauge", the whole gauge reacts to mouse and touch events.
                 * If "none", interactions are disabled.
                 *
                 */
                "interactionArea": string;
                /**
                 * Can be "mouse" or "touch".
                 *
                 */
                "interactionMode": string;
                /**
                 * The interval between two major ticks.
                 *
                 */
                "majorTickInterval": number;
                /**
                 * The maximum value of the scaler. Default is 100.
                 *
                 */
                "maximum": number;
                /**
                 * The minimum value of the scaler. Default is 0.
                 *
                 */
                "minimum": number;
                /**
                 * The interval between two minor ticks.
                 *
                 */
                "minorTickInterval": number;
                /**
                 * If false, minor ticks are not generated. Default is true.
                 *
                 */
                "minorTicksEnabled": boolean;
                /**
                 * Specifies the increment value to be used as snap values on this scale
                 * during user interaction.
                 * Default is 1.
                 *
                 */
                "snapInterval": number;
                /**
                 *
                 */
                "value": number;
            }
            namespace black {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/black/CircularLinearGauge.html
                 *
                 * A circular gauge widget.
                 *
                 */
                class CircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#000000".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#000000".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#A4A4A4".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/black/HorizontalLinearGauge.html
                 *
                 * A horizontal gauge widget.
                 *
                 */
                class HorizontalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#000000".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#000000".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#A4A4A4".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/black/SemiCircularLinearGauge.html
                 *
                 * A semi circular gauge widget.
                 *
                 */
                class SemiCircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#000000".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#000000".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#A4A4A4".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/black/VerticalLinearGauge.html
                 *
                 * A vertical gauge widget.
                 *
                 */
                class VerticalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#000000".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#000000".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#A4A4A4".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
            }

            namespace classic {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/classic/HorizontalLinearGauge.html
                 *
                 * A horizontal gauge widget.
                 *
                 */
                class HorizontalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#797E86".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#FFFFFF".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/classic/CircularLinearGauge.html
                 *
                 * A circular gauge widget.
                 *
                 */
                class CircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#797E86".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#FFFFFF".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/classic/SemiCircularLinearGauge.html
                 *
                 * A semi circular gauge widget.
                 *
                 */
                class SemiCircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#797E86".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#FFFFFF".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/classic/VerticalLinearGauge.html
                 *
                 * A vertical gauge widget.
                 *
                 */
                class VerticalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#797E86".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#FFFFFF".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
            }

            namespace default_ {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/default/SemiCircularLinearGauge.html
                 *
                 * A semi circular gauge widget.
                 *
                 */
                class SemiCircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#C9DFF2".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#FCFCFF".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#F01E28".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/default/HorizontalLinearGauge.html
                 *
                 * A horizontal gauge widget.
                 *
                 */
                class HorizontalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#C9DFF2".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#FCFCFF".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#F01E28".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/default/CircularLinearGauge.html
                 *
                 * A circular gauge widget.
                 *
                 */
                class CircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#C9DFF2".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#FCFCFF".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#F01E28".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/default/VerticalLinearGauge.html
                 *
                 * A vertical gauge widget.
                 *
                 */
                class VerticalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#C9DFF2".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#FCFCFF".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#F01E28".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
            }

            namespace green {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/green/CircularLinearGauge.html
                 *
                 * A circular gauge widget.
                 *
                 */
                class CircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#323232".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The fill color. Default is "#6DB713".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#000000".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/green/HorizontalLinearGauge.html
                 *
                 * A horizontal gauge widget.
                 *
                 */
                class HorizontalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#323232".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#6DB713".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#000000".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/green/SemiCircularLinearGauge.html
                 *
                 * A semi circular gauge widget.
                 *
                 */
                class SemiCircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#323232".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The fill color. Default is "#6DB713".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#000000".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/green/VerticalLinearGauge.html
                 *
                 * A vertical gauge widget.
                 *
                 */
                class VerticalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#323232".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#6DB713".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#000000".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
            }

            namespace grey {
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/grey/SemiCircularLinearGauge.html
                 *
                 * A semi circular gauge widget.
                 *
                 * @param args
                 * @param node
                 */
                class SemiCircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor(args: any, node: any);
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#9498A1".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#3F3F3F".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/grey/CircularLinearGauge.html
                 *
                 * A circular gauge widget.
                 *
                 * @param args
                 * @param node
                 */
                class CircularLinearGauge extends dojox.dgauges.CircularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor(args: any, node: any);
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#9498A1".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#3F3F3F".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", 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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.A Scale instance, i.e. CircularScale or RectangularScale.A TextIndicator instance.
                     */
                    addElement(name: String, element: Object): any;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     */
                    drawBackground(g: dojox.gfx.Group): void;
                    /**
                     * Draws the foreground shape of the gauge.
                     *
                     * @param g The group used to draw the foreground.
                     */
                    drawForeground(g: dojox.gfx.Group): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/grey/HorizontalLinearGauge.html
                 *
                 * A horizontal gauge widget.
                 *
                 */
                class HorizontalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#9498A1".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#3F3F3F".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
                /**
                 * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/grey/VerticalLinearGauge.html
                 *
                 * A vertical gauge widget.
                 *
                 */
                class VerticalLinearGauge extends dojox.dgauges.RectangularGauge implements dojox.dgauges.components.DefaultPropertiesMixin {
                    constructor();
                    /**
                     * The duration of the value change animation in milliseconds. Default is 0.
                     * The animation occurs on both user interactions and programmatic value changes.
                     * Set this property to 0 to disable animation.
                     *
                     */
                    "animationDuration": number;
                    set(property:"animationDuration", value: number): void;
                    get(property:"animationDuration"): number;
                    watch(property:"animationDuration", callback:{(property?:string, oldValue?:number, newValue?: number):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}
                    /**
                     * The border color. Default is "#9498A1".
                     *
                     */
                    "borderColor": Object;
                    set(property:"borderColor", value: Object): void;
                    get(property:"borderColor"): Object;
                    watch(property:"borderColor", 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}
                    /**
                     * The background color. Default is "#9498A1".
                     *
                     */
                    "fillColor": Object;
                    set(property:"fillColor", value: Object): void;
                    get(property:"fillColor"): Object;
                    watch(property:"fillColor", 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}
                    /**
                     * The font of the gauge used by elements if not overridden.
                     *
                     */
                    "font": Object;
                    set(property:"font", value: Object): void;
                    get(property:"font"): Object;
                    watch(property:"font", 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}
                    /**
                     * The indicator fill color. Default is "#3F3F3F".
                     *
                     */
                    "indicatorColor": Object;
                    set(property:"indicatorColor", value: Object): void;
                    get(property:"indicatorColor"): Object;
                    watch(property:"indicatorColor", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     * How to interact with the indicator using mouse or touch interactions.
                     * Can be "indicator", "gauge" or "none". The default value is "gauge".
                     * If set to "indicator", the indicator shape reacts to mouse and touch events.
                     * If set to "gauge", the whole gauge reacts to mouse and touch events.
                     * If "none", interactions are disabled.
                     *
                     */
                    "interactionArea": string;
                    set(property:"interactionArea", value: string): void;
                    get(property:"interactionArea"): string;
                    watch(property:"interactionArea", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     * Can be "mouse" or "touch".
                     *
                     */
                    "interactionMode": string;
                    set(property:"interactionMode", value: string): void;
                    get(property:"interactionMode"): string;
                    watch(property:"interactionMode", callback:{(property?:string, oldValue?:string, newValue?: string):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidatingProperties": Object;
                    set(property:"invalidatingProperties", value: Object): void;
                    get(property:"invalidatingProperties"): Object;
                    watch(property:"invalidatingProperties", callback:{(property?:string, oldValue?:Object, newValue?: Object):void}) :{unwatch():void}
                    /**
                     *
                     */
                    "invalidRendering": boolean;
                    set(property:"invalidRendering", value: boolean): void;
                    get(property:"invalidRendering"): boolean;
                    watch(property:"invalidRendering", 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 interval between two major ticks.
                     *
                     */
                    "majorTickInterval": number;
                    set(property:"majorTickInterval", value: number): void;
                    get(property:"majorTickInterval"): number;
                    watch(property:"majorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * The maximum value of the scaler. Default is 100.
                     *
                     */
                    "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 of the scaler. Default is 0.
                     *
                     */
                    "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}
                    /**
                     * The interval between two minor ticks.
                     *
                     */
                    "minorTickInterval": number;
                    set(property:"minorTickInterval", value: number): void;
                    get(property:"minorTickInterval"): number;
                    watch(property:"minorTickInterval", callback:{(property?:string, oldValue?:number, newValue?: number):void}) :{unwatch():void}
                    /**
                     * If false, minor ticks are not generated. Default is true.
                     *
                     */
                    "minorTicksEnabled": boolean;
                    set(property:"minorTicksEnabled", value: boolean): void;
                    get(property:"minorTicksEnabled"): boolean;
                    watch(property:"minorTicksEnabled", callback:{(property?:string, oldValue?:boolean, newValue?: boolean):void}) :{unwatch():void}
                    /**
                     * The orientation of the gauge. Default is "horizontal".
                     *
                     */
                    "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}
                    /**
                     * Specifies the increment value to be used as snap values on this scale
                     * during user interaction.
                     * Default is 1.
                     *
                     */
                    "snapInterval": number;
                    set(property:"snapInterval", value: number): void;
                    get(property:"snapInterval"): number;
                    watch(property:"snapInterval", 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}
                    /**
                     * This property acts as a top-level wrapper for the value of the first indicator added to
                     * its scale with the name "indicator", i.e. myScale.addIndicator("indicator", myIndicator).
                     * This property must be manipulated with get("value") and set("value", xxx).
                     *
                     */
                    "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}
                    /**
                     * Adds a element to the gauge.
                     *
                     * @param name The name of the element to be added.
                     * @param element This parameter can be:- A function which takes on argument of type GFX Group and return null or aGFX element retrievable using the getElementRenderer() method.- A Scale instance, i.e. CircularScale or RectangularScale.- A TextIndicator instance.
                     * @param location The area to place the element. Valid values are "leading"|"middle"|"trailing". Leading and trailing areas are fixed size. Themiddle area use the remaining size. If not specified, the element's refreshRendering is called with the whole gauge size as argument.
                     */
                    addElement(name: String, element: Object, location: String): void;
                    /**
                     * Add properties to the watched properties to trigger invalidation. This method must be called in
                     * the constructor. It is typically used by subclasses of a _Invalidating class to add more properties
                     * to watch for.
                     *
                     * @param properties The list of properties to watch for.
                     */
                    addInvalidatingProperties(properties: String[]): 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;
                    /**
                     * Cleanup when a gauge is to be destroyed.
                     *
                     */
                    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;
                    /**
                     * Draws the background shape of the gauge.
                     *
                     * @param g The group used to draw the background.
                     * @param w The width of the gauge.
                     * @param h The height of the gauge.
                     */
                    drawBackground(g: dojox.gfx.Group, w: number, h: number): 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[];
                    /**
                     * Get the given element, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElement(name: String): any;
                    /**
                     * Get the given element renderer, by name.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    getElementRenderer(name: String): any;
                    /**
                     * Returns the parent widget of this widget.
                     *
                     */
                    getParent(): any;
                    /**
                     * Invalidating the rendering for the next executation frame.
                     *
                     */
                    invalidateRendering(): 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;
                    /**
                     * 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;
                    /**
                     *
                     */
                    refreshRendering(): void;
                    /**
                     * Remove the element defined by name from the gauge.
                     *
                     * @param name The name of the element as defined using addElement.
                     */
                    removeElement(name: String): Object;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: number, height: number): any;
                    /**
                     * Resize the gauge to the dimensions of width and height.
                     * Resize the gauge and its surface to the width and height dimensions.
                     * If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
                     * Finally if no argument is provided, resize the surface to the marginBox of the gauge.
                     *
                     * @param width               OptionalThe new width of the gauge or the box definition.
                     * @param height               OptionalThe new height of the gauge.
                     */
                    resize(width: Object, height: 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;
                    /**
                     * 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;
                    /**
                     * Immediately validate the rendering if it has been invalidated. You generally do not call that method yourself.
                     *
                     */
                    validateRendering(): 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 an interaction ends (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onEndEditing(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 an interaction begins (keyboard, mouse or gesture).
                     *
                     * @param event On object with a unique member "indicator". This member is a reference to the modified indicator.
                     */
                    onStartEditing(event: any): void;
                }
            }

            /**
             * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/components/utils.html
             *
             *
             */
            interface utils {
                /**
                 * Adjusts the brightness of a color.
                 *
                 * @param col The base color
                 * @param b A positive or negative value to adjust the brightness
                 */
                brightness(col: number, b: number): number;
                /**
                 * Creates a gradient object
                 *
                 * @param entries An array of numbers representing colors
                 */
                createGradient(entries: any[]): number;
                /**
                 * A helper method for configuring a circular gauge.
                 *
                 * @param scale A circular scale
                 * @param indicator A circular indicator
                 * @param originX The x-coordinate of the center of the scale (in pixels)
                 * @param originY The y-coordinate of the center of the scale (in pixels)
                 * @param radius The radius of the scale (in pixels)
                 * @param startAngle The start angle of the scale (in degrees)
                 * @param endAngle The end angle of the scale (in degrees)
                 * @param orientation               OptionalThe orientation of the scale, can be "clockwise" or "cclockwise"
                 * @param font               OptionalThe font used for the gauge
                 * @param labelPosition               OptionalThe position of the labels regarding
                 * @param tickShapeFunc               OptionalA drawing function for the ticks
                 */
                genericCircularGauge(scale: number, indicator: dojox.dgauges.IndicatorBase, originX: number, originY: number, radius: number, startAngle: number, endAngle: number, orientation: String, font: Object, labelPosition: String, tickShapeFunc: Object): number;
            }
        }

        /**
         * Permalink: http://dojotoolkit.org/api/1.9/dojox/dgauges/_circularUtils.html
         *
         *
         */
        interface _circularUtils {
        }
    }

}

declare module "dojox/dgauges/_circularUtils" {
    var exp: dojox.dgauges._circularUtils
    export=exp;
}
declare module "dojox/dgauges/CircularScale" {
    var exp: dojox.dgauges.CircularScale
    export=exp;
}
declare module "dojox/dgauges/CircularValueIndicator" {
    var exp: dojox.dgauges.CircularValueIndicator
    export=exp;
}
declare module "dojox/dgauges/CircularGauge" {
    var exp: dojox.dgauges.CircularGauge
    export=exp;
}
declare module "dojox/dgauges/CircularRangeIndicator" {
    var exp: dojox.dgauges.CircularRangeIndicator
    export=exp;
}
declare module "dojox/dgauges/IndicatorBase" {
    var exp: dojox.dgauges.IndicatorBase
    export=exp;
}
declare module "dojox/dgauges/LinearScaler" {
    var exp: dojox.dgauges.LinearScaler
    export=exp;
}
declare module "dojox/dgauges/LogScaler" {
    var exp: dojox.dgauges.LogScaler
    export=exp;
}
declare module "dojox/dgauges/MultiLinearScaler" {
    var exp: dojox.dgauges.MultiLinearScaler
    export=exp;
}
declare module "dojox/dgauges/GaugeBase" {
    var exp: dojox.dgauges.GaugeBase
    export=exp;
}
declare module "dojox/dgauges/RectangularScale" {
    var exp: dojox.dgauges.RectangularScale
    export=exp;
}
declare module "dojox/dgauges/RectangularSegmentedRangeIndicator" {
    var exp: dojox.dgauges.RectangularSegmentedRangeIndicator
    export=exp;
}
declare module "dojox/dgauges/RectangularRangeIndicator" {
    var exp: dojox.dgauges.RectangularRangeIndicator
    export=exp;
}
declare module "dojox/dgauges/RectangularValueIndicator" {
    var exp: dojox.dgauges.RectangularValueIndicator
    export=exp;
}
declare module "dojox/dgauges/ScaleBase" {
    var exp: dojox.dgauges.ScaleBase
    export=exp;
}
declare module "dojox/dgauges/TextIndicator" {
    var exp: dojox.dgauges.TextIndicator
    export=exp;
}
declare module "dojox/dgauges/ScaleIndicatorBase" {
    var exp: dojox.dgauges.ScaleIndicatorBase
    export=exp;
}
declare module "dojox/dgauges/RectangularGauge" {
    var exp: dojox.dgauges.RectangularGauge
    export=exp;
}
declare module "dojox/dgauges/components/utils" {
    var exp: dojox.dgauges.components.utils
    export=exp;
}
declare module "dojox/dgauges/components/DefaultPropertiesMixin" {
    var exp: dojox.dgauges.components.DefaultPropertiesMixin
    export=exp;
}
declare module "dojox/dgauges/components/black/CircularLinearGauge" {
    var exp: dojox.dgauges.components.black.CircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/black/SemiCircularLinearGauge" {
    var exp: dojox.dgauges.components.black.SemiCircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/black/HorizontalLinearGauge" {
    var exp: dojox.dgauges.components.black.HorizontalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/black/VerticalLinearGauge" {
    var exp: dojox.dgauges.components.black.VerticalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/classic/CircularLinearGauge" {
    var exp: dojox.dgauges.components.classic.CircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/classic/HorizontalLinearGauge" {
    var exp: dojox.dgauges.components.classic.HorizontalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/classic/VerticalLinearGauge" {
    var exp: dojox.dgauges.components.classic.VerticalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/classic/SemiCircularLinearGauge" {
    var exp: dojox.dgauges.components.classic.SemiCircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/default/CircularLinearGauge" {
    var exp: dojox.dgauges.components.default_.CircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/default/HorizontalLinearGauge" {
    var exp: dojox.dgauges.components.default_.HorizontalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/default/SemiCircularLinearGauge" {
    var exp: dojox.dgauges.components.default_.SemiCircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/default/VerticalLinearGauge" {
    var exp: dojox.dgauges.components.default_.VerticalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/green/HorizontalLinearGauge" {
    var exp: dojox.dgauges.components.green.HorizontalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/green/CircularLinearGauge" {
    var exp: dojox.dgauges.components.green.CircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/green/SemiCircularLinearGauge" {
    var exp: dojox.dgauges.components.green.SemiCircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/green/VerticalLinearGauge" {
    var exp: dojox.dgauges.components.green.VerticalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/grey/CircularLinearGauge" {
    var exp: dojox.dgauges.components.grey.CircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/grey/SemiCircularLinearGauge" {
    var exp: dojox.dgauges.components.grey.SemiCircularLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/grey/HorizontalLinearGauge" {
    var exp: dojox.dgauges.components.grey.HorizontalLinearGauge
    export=exp;
}
declare module "dojox/dgauges/components/grey/VerticalLinearGauge" {
    var exp: dojox.dgauges.components.grey.VerticalLinearGauge
    export=exp;
}