@afterswf/playerglobal 0.0.0-stage → 0.2.460

package/dist/lib/display/Stage.d.ts

@@ -0,0 +1,723 @@
+import { StageAlign, StageScaleMode } from '@awayfl/swf-loader';
+import { Event } from '../events/Event';
+import { DisplayObjectContainer } from './DisplayObjectContainer';
+import { DisplayObject } from './DisplayObject';
+import { View } from '@awayjs/view';
+import { Stage as AwayStage } from '@awayjs/stage';
+import { MouseEvent as MouseEventAway } from '@awayjs/scene';
+import { Transform } from '../geom/Transform';
+import { Rectangle } from '../geom/Rectangle';
+import { LoaderInfo } from './LoaderInfo';
+import { InteractiveObject } from './InteractiveObject';
+/**
+ * Dispatched by the Stage object when the state of the stageVideos property changes.
+ * @eventType	flash.events.StageVideoAvailabilityEvent.STAGE_VIDEO_AVAILABILITY
+ [Event(name="stageVideoAvailability", type="flash.events.StageVideoAvailabilityEvent")]
+
+ * Dispatched by the Stage object when the stage orientation changes.
+ * @eventType	flash.events.StageOrientationEvent.ORIENTATION_CHANGE
+ [Event(name="orientationChange", type="flash.events.StageOrientationEvent")]
+
+ * Dispatched by the Stage object when the stage orientation begins changing.
+ * @eventType	flash.events.StageOrientationEvent.ORIENTATION_CHANGING
+ [Event(name="orientationChanging", type="flash.events.StageOrientationEvent")]
+
+ * Dispatched when the Stage object enters, or leaves, full-screen mode.
+ * @eventType	flash.events.FullScreenEvent.FULL_SCREEN
+ [Event(name="fullScreen", type="flash.events.FullScreenEvent")]
+
+ * Dispatched when the scaleMode property of the Stage object is set to
+ * StageScaleMode.NO_SCALE and the SWF file is resized.
+ * @eventType	flash.events.Event.RESIZE
+ [Event(name="resize", type="flash.events.Event")]
+
+ * Dispatched by the Stage object when the pointer moves out of the
+ * stage area.
+ * @eventType	flash.events.Event.MOUSE_LEAVE
+ [Event(name="mouseLeave", type="flash.events.Event")]
+
+ * The Stage class represents the main drawing area.
+ *
+ *   <p class="- topic/p ">For SWF content running in the browser (in
+ * Flash<sup class="+ topic/ph hi-d/sup ">®</sup> Player), the Stage represents the entire area where Flash
+ * content is shown. For content running in AIR on desktop operating systems,
+ * each NativeWindow object has a corresponding
+ * Stage object.</p><p class="- topic/p ">The Stage object is not globally accessible.
+ * You need to access it through the
+ * <codeph class="+ topic/ph pr-d/codeph ">stage</codeph> property of a DisplayObject instance.
+ * </p><p class="- topic/p ">The Stage class has several ancestor classes — DisplayObjectContainer, InteractiveObject,
+ * DisplayObject, and EventDispatcher — from which it inherits properties and methods.
+ * Many of these properties and methods are either inapplicable to Stage objects,
+ * or require security checks when called on a Stage object.  The properties and methods that
+ * require security checks are documented as part of the Stage class.</p><p class="- topic/p ">
+ * In addition, the following inherited properties are inapplicable to Stage objects. If you
+ * try to set them, an IllegalOperationError is thrown. These properties may always be read, but
+ * since they cannot be set, they will always contain default values.</p><ul class="- topic/ul ">
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">accessibilityProperties</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">alpha</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">blendMode</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">cacheAsBitmap</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">contextMenu</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">filters</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">focusRect</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">loaderInfo</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">mask</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">mouseEnabled</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">name</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">opaqueBackground</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">rotation</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">scale9Grid</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">scaleX</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">scaleY</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">scrollRect</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">tabEnabled</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">tabIndex</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">transform</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">visible</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">x</codeph></li>
+ * <li class="- topic/li "><codeph class="+ topic/ph pr-d/codeph ">y</codeph></li>
+ * </ul>
+ * <p class="- topic/p ">Some events that you might expect to be a part of the Stage class,
+ * such as <codeph class="+ topic/ph pr-d/codeph ">enterFrame</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">exitFrame</codeph>,
+ * <codeph class="+ topic/ph pr-d/codeph ">frameConstructed</codeph>,
+ * and <codeph class="+ topic/ph pr-d/codeph ">render</codeph>,
+ * cannot be Stage events because a reference to the Stage object
+ * cannot be guaranteed to exist in every situation where these events
+ * are used. Because these events cannot be dispatched by the Stage
+ * object, they are instead dispatched by every DisplayObject instance,
+ * which means that you can add an event listener to
+ * any DisplayObject instance to listen for these events.
+ * These events, which are part of the DisplayObject class,
+ * are called broadcast events to differentiate them from events
+ * that target a specific DisplayObject instance.
+ * Two other broadcast events, <codeph class="+ topic/ph pr-d/codeph ">activate</codeph>
+ * and <codeph class="+ topic/ph pr-d/codeph ">deactivate</codeph>,
+ * belong to DisplayObject's superclass, EventDispatcher.
+ * The <codeph class="+ topic/ph pr-d/codeph ">activate</codeph>
+ * and <codeph class="+ topic/ph pr-d/codeph ">deactivate</codeph> events
+ * behave similarly to the DisplayObject broadcast events, except
+ * that these two events are dispatched not only by all DisplayObject
+ * instances, but also by all EventDispatcher instances and instances
+ * of other EventDispatcher subclasses.
+ * For more information on broadcast events, see the DisplayObject class.</p>
+ *
+ *   EXAMPLE:
+ *
+ *   The following example uses the <codeph class="+ topic/ph pr-d/codeph ">StageExample</codeph> class to dispatch
+ * events whenever the stage is activated or resized.  This is accomplished by performing the following steps:
+ * <ol class="- topic/ol "><li class="- topic/li ">
+ * The class constructor first sets the Flash application to be fixed, regardless of the size of
+ * the Flash Player window and then adds two event listeners with the
+ * <codeph class="+ topic/ph pr-d/codeph ">activateHandler()</codeph>
+ * and <codeph class="+ topic/ph pr-d/codeph ">resizeHandler()</codeph> methods.</li>
+ * <li class="- topic/li ">The <codeph class="+ topic/ph pr-d/codeph ">activateHandler()
+ * </codeph> method runs when the left mouse button is clicked.</li><li class="- topic/li ">
+ * The <codeph class="+ topic/ph pr-d/codeph ">resizeHandler()</codeph> method runs when the stage is resized.</li>
+ * </ol><codeblock xml:space="preserve" class="+ topic/pre pr-d/codeblock ">
+ * package {
+     * import flash.display.Sprite;
+     * import flash.display.StageAlign;
+     * import flash.display.StageScaleMode;
+     * import flash.events.Event;
+     *
+     *   public class StageExample extends Sprite {
+     *
+     *   public StageExample() {
+     * stage.scaleMode = StageScaleMode.NO_SCALE;
+     * stage.align = StageAlign.TOP_LEFT;
+     * stage.addEventListener(Event.ACTIVATE, activateHandler);
+     * stage.addEventListener(Event.RESIZE, resizeHandler);
+     * }
+     *
+     *   private activateHandler(event:Event):void {
+     * trace("activateHandler: " + event);
+     * }
+     *
+     *   private resizeHandler(event:Event):void {
+     * trace("resizeHandler: " + event);
+     * trace("stageWidth: " + stage.stageWidth + " stageHeight: " + stage.stageHeight);
+     * }
+     * }
+     * }
+ * </codeblock>
+ */
+export declare class Stage extends DisplayObjectContainer {
+    private _stage3Ds;
+    private _sendEventRender;
+    constructor();
+    get view(): View;
+    private initResizeListener;
+    private removeResizeListener;
+    private _resizeCallbackDelegate;
+    resizeCallback(event?: any): void;
+    show(): void;
+    private initMouseLeaveListener;
+    private removeMouseLeaveListener;
+    protected initListener(type: string, callback: (event: MouseEventAway) => void, listener: Function): void;
+    protected removeListener(type: string, callback: (event: MouseEventAway) => void, listener: Function): void;
+    private _mouseLeaveCallbackDelegate;
+    private mouseLeaveCallback;
+    enterFrame(): void;
+    get mouseX(): number;
+    /**
+     * Indicates the y coordinate of the mouse or user input device position, in pixels.
+     *
+     *   Note: For a DisplayObject that has been rotated, the returned y coordinate will reflect the
+     * non-rotated any.
+     */
+    get mouseY(): number;
+    set accessibilityImplementation(value: any);
+    /**
+     * A value from the StageAlign class that specifies the alignment of the stage in
+     * Flash Player or the browser. The following are valid values:
+     *
+     *   ValueVertical
+     * AlignmentHorizontalStageAlign.TOP
+     * TopCenterStageAlign.BOTTOM
+     * BottomCenterStageAlign.LEFT
+     * CenterLeftStageAlign.RIGHT
+     * CenterRightStageAlign.TOP_LEFT
+     * TopLeftStageAlign.TOP_RIGHT
+     * TopRightStageAlign.BOTTOM_LEFT
+     * BottomLeftStageAlign.BOTTOM_RIGHT
+     * BottomRight
+     * The align property is only available to an object that is in the same security sandbox
+     * as the Stage owner (the main SWF file).
+     * To avoid this, the Stage owner can grant permission to the domain of the
+     * calling object by calling the Security.allowDomain() method or the Security.alowInsecureDomain() method.
+     * For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get align(): StageAlign;
+    set align(value: StageAlign);
+    /**
+     * Specifies whether this stage allows the use of the full screen mode
+     * @langversion	3.0
+     * @playerversion	Flash 10.2
+     * @oldexample	The following example traces the value of this read-only property:
+     *   <pre xml:space="preserve" class="- topic/pre ">
+     *   trace(Stage.allowsFullsreen);
+     *   </pre>
+     */
+    get allowsFullScreen(): boolean;
+    get allowsFullScreenInteractive(): boolean;
+    get browserZoomFactor(): number;
+    get color(): number;
+    set color(color: number);
+    /**
+     * Controls Flash runtime color correction for displays.
+     * Color correction works only if the main monitor is assigned a valid ICC color profile, which specifies
+     * the device's particular color attributes.
+     * By default, the Flash runtime tries to match the color correction of its host (usually a browser).
+     *
+     *   Use the Stage.colorCorrectionSupport property
+     * to determine if color correction is available on the current system and the default state.
+     * .    If color correction is available, all colors on the stage are assumed to be in
+     * the sRGB color space, which is the most standard color space.
+     * Source profiles of input devices are not considered during color correction.
+     * No input color correction is applied; only the stage output is mapped to the main
+     * monitor's ICC color profile.In general, the benefits of activating color management include predictable
+     * and consistent color, better conversion,
+     * accurate proofing and more efficient cross-media output. Be aware, though, that color management does not provide
+     * perfect conversions due to devices having a different gamut from each other or original images.
+     * Nor does color management eliminate the need for custom or edited profiles.
+     * Color profiles are dependent on browsers, operating systems (OS), OS extensions,
+     * output devices, and application support.Applying color correction degrades the Flash runtime performance.
+     * A Flash runtime's color correction is document style color correction because
+     * all SWF movies are considered documents with implicit sRGB profiles.
+     * Use the Stage.colorCorrectionSupport property to tell the Flash runtime
+     * to correct colors when displaying the SWF file (document) to the display color space.
+     * Flash runtimes only compensates for differences between monitors, not for differences between input devices
+     * (camera/scanner/etc.).
+     * The three possible values are strings with corresponding constants in the flash.display.ColorCorrection
+     * class:"default": Use the same color correction as the host system."on":
+     * Always perform color correction."off": Never perform color correction.
+     */
+    get colorCorrection(): string;
+    set colorCorrection(value: string);
+    /**
+     * Specifies whether the Flash runtime is running on an operating system that supports
+     * color correction and whether the color profile of the main (primary)
+     * monitor can be read and understood by the Flash runtime. This property also returns the default state
+     * of color correction on the host system (usually the browser).
+     * Currently the return values can be:
+     * The three possible values are strings with corresponding constants in the
+     * flash.display.ColorCorrectionSupport class:"unsupported":
+     * Color correction is not available."defaultOn":
+     * Always performs color correction."defaultOff": Never performs color correction.
+
+     */
+    get colorCorrectionSupport(): string;
+    get contentsScaleFactor(): number;
+    get displayContextInfo(): string;
+    /**
+     * A value from the StageDisplayState class that specifies which display state to use. The following
+     * are valid values:
+     *
+     *   StageDisplayState.FULL_SCREEN Sets AIR application or Flash runtime to expand the
+     * stage over the user's entire screen, with keyboard input disabled.StageDisplayState.FULL_SCREEN_INTERACTIVE
+     * Sets the AIR application to expand the
+     * stage over the user's entire screen, with keyboard input allowed.
+     * (Not available for content running in Flash Player.)StageDisplayState.NORMAL
+     * Sets the Flash runtime back to the standard stage display mode.
+     * The scaling behavior of the movie in full-screen mode is determined by the scaleMode
+     * setting (set using the Stage.scaleMode property or the SWF file's embed
+     * tag settings in the HTML file). If the scaleMode property is set to noScale
+     * while the application transitions to full-screen mode, the Stage width and height
+     * properties are updated, and the Stage dispatches a resize event. If any other scale mode is set,
+     * the stage and its contents are scaled to fill the new screen dimensions. The Stage object retains its original
+     * width and height values and does not dispatch a resize event.
+     * The following restrictions apply to SWF files that play within an HTML page (not those using the stand-alone
+     * Flash Player or not running in the AIR runtime):To enable full-screen mode,
+     * add the allowFullScreen parameter to the object
+     * and embed tags in the HTML page that includes the SWF file, with allowFullScreen set
+     * to "true", as shown in the following example:
+     *
+     *   <codeblock>
+     * <param name="allowFullScreen" value="true" />
+     * ...
+     * <embed src="example.swf" allowFullScreen="true" ... >
+     * </codeblock>
+     * An HTML page may also use a script to generate SWF-embedding tags. You need to alter the script
+     * so that it inserts the proper allowFullScreen settings. HTML pages generated by Flash Professional and
+     * Flash Builder use the AC_FL_RunContent() to embed references to SWF files, and you
+     * need to add the allowFullScreen parameter settings, as in the following:
+     * <codeblock>
+     * AC_FL_RunContent( ... "allowFullScreen", "true", ... )
+     * </codeblock>
+     * Full-screen mode is initiated in response to a mouse click or key press by the user; the movie cannot change
+     * Stage.displayState without user input. Flash runtimes restrict keyboard input  in full-screen mode.
+     * Acceptable keys include keyboard shortcuts that terminate full-screen mode and non-printing keys such as arrows,
+     * space, Shift,
+     * and Tab keys. Keyboard shortcuts that terminate full-screen mode are:
+     * Escape (Windows, Linux, and Mac), Control+W (Windows),
+     * Command+W (Mac), and Alt+F4.
+     * A Flash runtime dialog box appears over the movie when users enter full-screen mode
+     * to inform the users they are in
+     * full-screen mode and that they can press the Escape key to end full-screen mode.
+     * Starting with Flash Player 9.0.115.0, full-screen works the same in windowless mode as it does in window mode.
+     * If you set the Window Mode (wmode in the HTML) to Opaque Windowless (opaque)
+     * or Transparent Windowless (transparent), full-screen can be initiated,
+     * but the full-screen window will always be opaque.
+     * These restrictions are not present for SWF content running in the
+     * stand-alone Flash Player or in AIR.
+     * AIR supports an interactive full-screen mode which allows keyboard input.
+     * For AIR content running in full-screen mode, the system screen saver
+     * and power saving options are disabled while video content is playing and until either the video stops
+     * or full-screen mode is exited.On Linux, setting displayState to StageDisplayState.FULL_SCREEN or
+     * StageDisplayState.FULL_SCREEN_INTERACTIVE is an asynchronous operation.
+     * @throws	SecurityError Calling the displayState property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     *   Trying to set the displayState property while the settings dialog is displayed, without a user response, or
+     *   if the param or embed HTML tag's allowFullScreen attribute is not set to
+     *   true throws a security error.
+     */
+    get displayState(): string;
+    set displayState(value: string);
+    /**
+     * The interactive object with keyboard focus; or null if focus is not set
+     * or if the focused object belongs to a security sandbox to which the calling object does not
+     * have access.
+     * @throws	Error Throws an error if focus cannot be set to the target.
+     */
+    get focus(): InteractiveObject;
+    set focus(newFocus: InteractiveObject);
+    /**
+     * Gets and sets the frame rate of the stage. The frame rate is defined as frames per second.
+     * By default the rate is set to the frame rate of the first SWF file loaded. Valid range for the frame rate
+     * is from 0.01 to 1000 frames per second.
+     *
+     *   Note: An application might not be able to follow
+     * high frame rate settings, either because the target platform is not fast enough or the player is
+     * synchronized to the vertical blank timing of the display device (usually 60 Hz on LCD devices).
+     * In some cases, a target platform might also choose to lower the maximum frame rate if it
+     * anticipates high CPU usage.For content running in Adobe AIR, setting the frameRate property of one Stage
+     * object changes the frame rate for all Stage objects (used by different NativeWindow objects).
+     * @throws	SecurityError Calling the frameRate property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get frameRate(): number;
+    set frameRate(value: number);
+    /**
+     * Returns the height of the monitor that will be used when going to full screen size, if that state
+     * is entered immediately. If the user has multiple monitors, the monitor that's used is the
+     * monitor that most of the stage is on at the time.
+     *
+     *   Note: If the user has the opportunity to move the browser from one
+     * monitor to another between retrieving the value and going to full screen
+     * size, the value could be incorrect. If you retrieve the value in an event handler that
+     * sets Stage.displayState to StageDisplayState.FULL_SCREEN, the value will be
+     * correct.This is the pixel height of the monitor and is the same as the
+     * stage height would be if Stage.align is set to StageAlign.TOP_LEFT
+     * and Stage.scaleMode is set to StageScaleMode.NO_SCALE.
+     */
+    get fullScreenHeight(): number;
+    /**
+     * Sets the Flash runtime to scale a specific region of the stage to full-screen mode.
+     * If available, the Flash runtime scales in hardware, which uses the graphics and video card on a user's computer,
+     * and generally displays content more quickly than software scaling.
+     *
+     *   When this property is set to a valid rectangle and the displayState property is set to full-screen mode,
+     * the Flash runtime scales the specified area. The actual Stage size in pixels within ActionScript does not change.
+     * The Flash runtime enforces a minimum limit for the size of the rectangle to accommodate the standard
+     * "Press Esc to exit full-screen mode" message.
+     * This limit is usually around 260 by 30 pixels but can vary on platform and Flash runtime version.
+     * This property can only be set when the Flash runtime is not in full-screen mode.
+     * To use this property correctly, set this property first,
+     * then set the displayState property to full-screen mode, as shown in the code examples.To enable scaling,
+     * set the fullScreenSourceRect property to a rectangle object:
+     * <codeblock>
+     *
+     *   // valid, will enable hardware scaling
+     * stage.fullScreenSourceRect = new Rectangle(0,0,320,240);
+     *
+     *   </codeblock>
+     * To disable scaling, set the fullScreenSourceRect=null in ActionScript 3.0, and undefined in ActionScript 2.0.
+     * <codeblock>
+     *
+     *   stage.fullScreenSourceRect = null;
+     *
+     *   </codeblock>
+     * The end user also can select within Flash Player Display Settings to turn off hardware scaling,
+     * which is enabled by default.
+     * For more information, see www.adobe.com/go/display_settings.
+     */
+    get fullScreenSourceRect(): Rectangle;
+    set fullScreenSourceRect(value: Rectangle);
+    /**
+     * Returns the width of the monitor that will be used when going to full screen size, if that state
+     * is entered immediately. If the user has multiple monitors, the monitor that's used is the
+     * monitor that most of the stage is on at the time.
+     *
+     *   Note: If the user has the opportunity to move the browser from one
+     * monitor to another between retrieving the value and going to full screen
+     * size, the value could be incorrect. If you retrieve the value in an event handler that
+     * sets Stage.displayState to StageDisplayState.FULL_SCREEN, the value will be
+     * correct.This is the pixel width of the monitor and is the same as the stage width would be if
+     * Stage.align is set to StageAlign.TOP_LEFT and
+     * Stage.scaleMode is set to StageScaleMode.NO_SCALE.
+     */
+    get fullScreenWidth(): number;
+    get mouseLock(): boolean;
+    set mouseLock(value: boolean);
+    /**
+     * A value from the StageQuality class that specifies which rendering quality is used.
+     * The following are valid values:
+     *
+     *   StageQuality.LOW—Low rendering quality. Graphics are not
+     * anti-aliased, and bitmaps are not smoothed, but runtimes still use mip-mapping.StageQuality.
+     * MEDIUM—Medium rendering quality. Graphics are
+     * anti-aliased using a 2 x 2 pixel grid, bitmap smoothing is dependent on the Bitmap.smoothing setting.
+     * Runtimes use mip-mapping. This setting is suitable for movies that do not contain text.
+     * StageQuality.HIGH—High rendering quality. Graphics are anti-aliased
+     * using a 4 x 4 pixel grid, and bitmap smoothing is dependent on the Bitmap.smoothing setting.
+     * Runtimes use mip-mapping. This is the default rendering quality setting that Flash Player uses.
+     * StageQuality.BEST—Very high rendering quality. Graphics are
+     * anti-aliased using a 4 x 4 pixel grid. If Bitmap.smoothing is true the runtime uses a high quality
+     * downscale algorithm that produces fewer artifacts
+     * (however, using StageQuality.BEST with Bitmap.smoothing set to true
+     * slows performance significantly and is not a recommended setting).
+     * Higher quality settings produce better rendering of scaled bitmaps. However, higher
+     * quality settings are computationally more expensive. In particular, when rendering scaled video,
+     * using higher quality settings can reduce the frame rate.
+     * In the desktop profile of Adobe AIR, quality can be set
+     * to StageQuality.BEST or StageQuality.HIGH (and the default value
+     * is StageQuality.HIGH). Attempting to set it to another value has no effect
+     * (and the property remains unchanged). In the moble profile of AIR, all four quality settings
+     * are available. The default value on mobile devices is StageQuality.MEDIUM.
+     * For content running in Adobe AIR, setting the quality property of one Stage
+     * object changes the rendering quality for all Stage objects (used by different NativeWindow objects).
+     * Note: The operating system draws the device fonts,
+     * which are therefore unaffected by the quality property.
+     * @throws	SecurityError Calling the quality property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get quality(): string;
+    set quality(value: string);
+    /**
+     * A value from the StageScaleMode class that specifies which scale mode to use.
+     * The following are valid values:
+     *
+     *   StageScaleMode.EXACT_FIT—The entire application is visible
+     * in the specified area without trying to preserve the original aspect ratio.
+     * Distortion can occur, and the application may appear stretched or compressed.
+     * StageScaleMode.SHOW_ALL—The entire application is visible
+     * in the specified area without distortion while maintaining the original aspect ratio of the application.
+     * Borders can appear on two sides of the application.
+     * StageScaleMode.NO_BORDER—The entire application fills the specified area,
+     * without distortion but possibly with some cropping, while maintaining the original aspect ratio
+     * of the application.
+     * StageScaleMode.NO_SCALE—The entire application is fixed, so that
+     * it remains unchanged even as the size of the player window changes. Cropping might
+     * occur if the player window is smaller than the content.
+     * @throws	SecurityError Calling the scaleMode property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get scaleMode(): StageScaleMode;
+    set scaleMode(value: StageScaleMode);
+    /**
+     * Specifies whether to show or hide the default items in the Flash runtime
+     * context menu.
+     *
+     *   If the showDefaultContextMenu property is set to true (the
+     * default), all context menu items appear. If the showDefaultContextMenu property
+     * is set to false, only the Settings and About... menu items appear.
+     * @throws	SecurityError Calling the showDefaultContextMenu property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get showDefaultContextMenu(): boolean;
+    set showDefaultContextMenu(value: boolean);
+    /**
+     * The area of the stage that is currently covered by the software keyboard.
+     *
+     *   The area has a size of zero (0,0,0,0) when the soft keyboard is not visible.
+     * When the keyboard opens, the softKeyboardRect is set at the time the
+     * softKeyboardActivate event is dispatched. If the keyboard changes size while open,
+     * the runtime updates the softKeyboardRect property and dispatches an
+     * additional softKeyboardActivate event.Note: On Android, the area covered by the keyboard is estimated when
+     * the operating system does not provide the information necessary to determine the exact
+     * area. This problem occurs in fullscreen mode and also when the keyboard opens in response to
+     * an InteractiveObject receiving focus or invoking the requestSoftKeyboard() method.
+     */
+    get softKeyboardRect(): Rectangle;
+    get stage3Ds(): AwayStage[];
+    get stage(): Stage;
+    set stage(value: Stage);
+    /**
+     * Specifies whether or not objects display a glowing border when they have focus.
+     * @throws	SecurityError Calling the stageFocusRect property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get stageFocusRect(): boolean;
+    set stageFocusRect(on: boolean);
+    /**
+     * The current height, in pixels, of the Stage.
+     *
+     *   If the value of the Stage.scaleMode property is set to StageScaleMode.NO_SCALE
+     * when the user resizes the window, the Stage content maintains its size while the
+     * stageHeight property changes to reflect the new height size of the screen area occupied by
+     * the SWF file. (In the other scale modes, the stageHeight property always reflects the original
+     * height of the SWF file.) You can add an event listener for the resize event and then use the
+     * stageHeight property of the Stage class to determine the actual pixel dimension of the resized
+     * Flash runtime window. The event listener allows you to control how
+     * the screen content adjusts when the user resizes the window.
+     * Air for TV devices have slightly different behavior than desktop devices
+     * when you set the stageHeight property.
+     * If the Stage.scaleMode
+     * property is set to StageScaleMode.NO_SCALE and you set the stageHeight
+     * property, the stage height does not change until the next
+     * frame of the SWF.Note: In an HTML page hosting the SWF file,
+     * both the object and embed tags' height attributes must be set to a percentage (such as 100%), not pixels. If the
+     * settings are generated by JavaScript code, the height parameter of the AC_FL_RunContent()
+     * method must be set to a percentage, too. This percentage is applied to the stageHeight
+     * value.
+     * @throws	SecurityError Calling the stageHeight property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get stageHeight(): number;
+    set stageHeight(value: number);
+    /**
+     * A list of StageVideo objects available for playing external videos.
+     *
+     *   You can use only a limited number of StageVideo objects at a time.
+     * When a SWF begins to run, the number of available StageVideo objects depends on the platform
+     * and on available hardware.
+     * To use a StageVideo object, assign a member of the stageVideos Vector object to a StageVideo variable.
+     * All StageVideo objects are displayed on the stage behind any display objects.
+     * The StageVideo objects are displayed on the stage in the order they appear in
+     * the stageVideos Vector object. For example, if the stageVideos Vector object contains
+     * three entries:The StageVideo object in the 0 index of the stageVideos Vector object is
+     * displayed behind all StageVideo objects.The StageVideo object at index 1 is displayed in front
+     * of the StageVideo object at index 0.The StageVideo object at index 2 is displayed in front
+     * of the StageVideo object at index 1.Use the StageVideo.depth property to change this ordering.
+     * Note: AIR for TV devices support only one StageVideo object.
+     */
+    get stageVideos(): any[];
+    /**
+     * Specifies the current width, in pixels, of the Stage.
+     *
+     *   If the value of the Stage.scaleMode property is set to StageScaleMode.NO_SCALE
+     * when the user resizes the window, the Stage content maintains its defined size while the stageWidth
+     * property changes to reflect the new width size of the screen area occupied by the SWF file. (In the other scale
+     * modes, the stageWidth property always reflects the original width of the SWF file.) You can add an event
+     * listener for the resize event and then use the stageWidth property of the Stage class to
+     * determine the actual pixel dimension of the resized Flash runtime window.
+     * The event listener allows you to control how
+     * the screen content adjusts when the user resizes the window.
+     * Air for TV devices have slightly different behavior than desktop devices
+     * when you set the stageWidth property.
+     * If the Stage.scaleMode
+     * property is set to StageScaleMode.NO_SCALE and you set the stageWidth
+     * property, the stage width does not change until the next
+     * frame of the SWF.Note: In an HTML page hosting the SWF file,
+     * both the object and embed tags' width attributes must be set to a percentage (such as 100%), not pixels. If the
+     * settings are generated by JavaScript code, the width parameter of the AC_FL_RunContent()
+     * method must be set to a percentage, too. This percentage is applied to the stageWidth
+     * value.
+     * @throws	SecurityError Calling the stageWidth property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get stageWidth(): number;
+    set stageWidth(value: number);
+    /**
+     * Determines whether the children of the object are tab enabled. Enables or disables tabbing for the
+     * children of the object. The default is true.
+     * Note: Do not use the tabChildren property with Flex.
+     * Instead, use the mx.core.UIComponent.hasFocusableChildren property.
+     * @throws	SecurityError Referencing the tabChildren property of a Stage object throws an exception for
+     *   any caller that is not in the same security sandbox as the Stage owner (the main SWF file).
+     *   To avoid this, the Stage owner can grant permission to the domain of the caller by calling
+     *   the Security.allowDomain() method or the Security.allowInsecureDomain() method.
+     *   For more information, see the "Security" chapter in the ActionScript 3.0 Developer's Guide.
+     */
+    get tabChildren(): boolean;
+    /**
+     * Returns a TextSnapshot object for this DisplayObjectContainer instance.
+     * @throws	IllegalOperationError Referencing the textSnapshot property of a Stage object throws an
+     *   exception because the Stage class does not implement this property. To avoid this, call the
+     *   textSnapshot property of a display object container other than the Stage object.
+     */
+    get textSnapshot(): any;
+    /**
+     * Indicates whether GPU compositing is available and in use. The wmodeGPU value is trueonly
+     * when all three of the following conditions exist:
+     * GPU compositing has been requested.GPU compositing is available.
+     * GPU compositing is in use.Specifically, the wmodeGPU property indicates one of the following:
+     * GPU compositing has not been requested or is unavailable. In this case, the wmodeGPU property value is false.
+     * GPU compositing has been requested (if applicable and available),
+     * but the environment is operating in "fallback mode"
+     * (not optimal rendering) due to limitations of the content.
+     * In this case, the wmodeGPU property value is true.
+     * GPU compositing has been requested (if applicable and available),
+     *  and the environment is operating in the best mode. In this case, the
+     * wmodeGPU property value is also true.In other words, the wmodeGPU property identifies the capability
+     * and state of the rendering environment. For runtimes
+     * that do not support GPU compositing, such as AIR 1.5.2,
+     * the value is always false, because (as stated above) the value is
+     * true only when GPU compositing has been requested, is available, and is in use.
+     * The wmodeGPU property is useful to determine, at runtime, whether or not GPU compositing is in use.
+     * The value of wmodeGPU indicates if your content is going to be scaled by hardware, or not,
+     * so you can present graphics at the correct size.
+     * You can also determine if you're rendering in a fast path or not,
+     * so that you can adjust your content complexity accordingly.For Flash Player in a browser,
+     * GPU compositing can be requested by the value of gpu for the wmode HTML
+     * parameter in the page hosting the SWF file. For other configurations,
+     * GPU compositing can be requested in the header of a SWF file
+     * (set using SWF authoring tools).However,
+     * the wmodeGPU property does not identify the current rendering performance.
+     * Even if GPU compositing is "in use" the rendering
+     * process might not be operating in the best mode. To adjust your content for optimal rendering,
+     * use a Flash runtime debugger version,
+     * and set the DisplayGPUBlendsetting in your mm.cfg file.Note:
+     * This property is always false when referenced
+     * from ActionScript that runs before the runtime performs its first rendering
+     * pass.  For example, if you examine wmodeGPU from a script in Frame 1 of
+     * Adobe Flash Professional, and your SWF file is the first SWF file loaded in a new
+     * instance of the runtime, then the wmodeGPU value is false.
+     * To get an accurate value, wait until at least one rendering pass
+     * has occurred. If you write an event listener for the
+     * exitFrame event of any DisplayObject, the wmodeGPU value at
+     * is the correct value.
+     */
+    get wmodeGPU(): boolean;
+    set accessibilityProperties(value: any);
+    set alpha(value: number);
+    set blendMode(value: string);
+    set cacheAsBitmap(value: boolean);
+    set contextMenu(value: any);
+    set filters(value: any);
+    set focusRect(value: any);
+    set mask(value: DisplayObject);
+    set mouseChildren(value: boolean);
+    get mouseChildren(): boolean;
+    set mouseEnabled(value: boolean);
+    get mouseEnabled(): boolean;
+    set numChildren(value: number);
+    get numChildren(): number;
+    set width(value: number);
+    get width(): number;
+    set height(value: number);
+    get height(): number;
+    set opaqueBackground(value: number);
+    set name(value: string);
+    set rotation(value: number);
+    set rotationX(value: number);
+    set rotationY(value: number);
+    set rotationZ(value: number);
+    set scale9Grid(value: Rectangle);
+    set scaleX(value: number);
+    set scaleY(value: number);
+    set scaleZ(value: number);
+    set scrollRect(value: Rectangle);
+    set tabEnabled(value: boolean);
+    set tabIndex(value: number);
+    set transform(value: Transform);
+    set visible(value: boolean);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    set z(value: number);
+    set tabChildren(value: boolean);
+    addChild(child: DisplayObject): DisplayObject;
+    addChildAt(child: DisplayObject, index: number): DisplayObject;
+    removeChildAt(index: number): DisplayObject;
+    swapChildrenAt(index: number, index2: number): void;
+    setChildIndex(child: DisplayObject, index: number): DisplayObject;
+    addEventListener(type: string, listener: any, useCapture?: boolean, priority?: number, useWeakReference?: boolean): void;
+    hasEventListener(type: string): boolean;
+    willTrigger(): void;
+    dispatchEvent(event: Event): boolean;
+    get loaderInfo(): LoaderInfo;
+    /**
+     * Calling the invalidate() method signals Flash runtimes to alert display objects
+     * on the next opportunity it has to render the display list (for example, when the playhead
+     * advances to a new frame). After you call the invalidate() method, when the display
+     * list is next rendered, the Flash runtime sends a render event to each display object that has
+     * registered to listen for the render event. You must call the invalidate()
+     * method each time you want the Flash runtime to send render events.
+     *
+     *   The render event gives you an opportunity to make changes to the display list
+     * immediately before it is actually rendered. This lets you defer updates to the display list until the
+     * latest opportunity. This can increase performance by eliminating unnecessary screen updates.
+     * The render event is dispatched only to display objects that are in the same
+     * security domain as the code that calls the stage.invalidate() method,
+     * or to display objects from a security domain that has been granted permission via the
+     * Security.allowDomain() method.
+     */
+    invalidate(): void;
+    /**
+     * Determines whether the Stage.focus property returns null for
+     * security reasons.
+     * In other words, isFocusInaccessible returns true if the
+     * object that has focus belongs to a security sandbox to which the SWF file does not have access.
+     * @return	true if the object that has focus belongs to a security sandbox to which
+     *   the SWF file does not have access.
+     */
+    isFocusInaccessible(): boolean;
+}
+//# sourceMappingURL=Stage.d.ts.map