pixi.js.d.ts

// Type definitions for pixi.js 4.8
// Project: https://github.com/pixijs/pixi.js/tree/v4.x
// Definitions by: clark-stevenson <https://github.com/clark-stevenson>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3

declare namespace PIXI {
    // from CONST
    /** String of the current PIXI version. */
    const VERSION: typeof CONST.VERSION;
    /** Two Pi. */
    const PI_2: typeof CONST.PI_2;
    /** Conversion factor for converting radians to degrees. */
    const RAD_TO_DEG: typeof CONST.RAD_TO_DEG;
    /** Conversion factor for converting degrees to radians. */
    const DEG_TO_RAD: typeof CONST.DEG_TO_RAD;
    /** Constant to identify the Renderer Type. */
    const RENDERER_TYPE: typeof CONST.RENDERER_TYPE;
    /**
     * Various blend modes supported by PIXI.
     *
     * IMPORTANT - The WebGL renderer only supports the NORMAL, ADD, MULTIPLY and SCREEN blend modes.
     * Anything else will silently act like NORMAL.
     */
    const BLEND_MODES: typeof CONST.BLEND_MODES;
    /**
     * Various webgl draw modes. These can be used to specify which GL drawMode to use
     * under certain situations and renderers.
     */
    const DRAW_MODES: typeof CONST.DRAW_MODES;
    /**
     * The scale modes that are supported by pixi.
     *
     * The {@link PIXI.settings.SCALE_MODE} scale mode affects the default scaling mode of future operations.
     * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
     */
    const SCALE_MODES: typeof CONST.SCALE_MODES;
    /**
     * The wrap modes that are supported by pixi.
     *
     * The {@link PIXI.settings.WRAP_MODE} wrap mode affects the default wrapping mode of future operations.
     * It can be re-assigned to either CLAMP or REPEAT, depending upon suitability.
     * If the texture is non power of two then clamp will be used regardless as webGL can
     * only use REPEAT if the texture is po2.
     *
     * This property only affects WebGL.
     */
    const WRAP_MODES: typeof CONST.WRAP_MODES;
    /**
     * Constants that specify the transform type.
     */
    const TRANSFORM_MODE: typeof CONST.TRANSFORM_MODE;
    /**
     * Constants that specify float precision in shaders.
     */
    const PRECISION: typeof CONST.PRECISION;
    /**
     * The gc modes that are supported by pixi.
     *
     * The {@link PIXI.settings.GC_MODE} Garbage Collection mode for PixiJS textures is AUTO
     * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
     * used for a specified period of time they will be removed from the GPU. They will of course
     * be uploaded again when they are required. This is a silent behind the scenes process that
     * should ensure that the GPU does not  get filled up.
     *
     * Handy for mobile devices!
     * This property only affects WebGL.
     */
    const GC_MODES: typeof CONST.GC_MODES;
    /**
     * Constants that identify shapes, mainly to prevent `instanceof` calls.
     */
    const SHAPES: typeof CONST.SHAPES;
    /**
     * Constants that define the type of gradient on text.
     */
    const TEXT_GRADIENT: typeof CONST.TEXT_GRADIENT;
    /**
     * Represents the update priorities used by internal PIXI classes when registered with
     * the {@link PIXI.ticker.Ticker} object. Higher priority items are updated first and lower
     * priority items, such as render, should go later.
     */
    const UPDATE_PRIORITY: typeof CONST.UPDATE_PRIORITY;

    function autoDetectRenderer(
        width: number,
        height: number,
        options?: PIXI.RendererOptions,
        forceCanvas?: boolean
    ): PIXI.WebGLRenderer | PIXI.CanvasRenderer;
    /**
     * This helper function will automatically detect which renderer you should be using.
     * WebGL is the preferred renderer as it is a lot faster. If webGL is not supported by
     * the browser then this function will return a canvas renderer
     * @param [options] - The optional renderer parameters
     * @param [options.width=800] - the width of the renderers view
     * @param [options.height=600] - the height of the renderers view
     * @param [options.view] - the canvas to use as a view, optional
     * @param [options.transparent=false] - If the render view is transparent, default false
     * @param [options.antialias=false] - sets antialias (only applicable in chrome at the moment)
     * @param [options.preserveDrawingBuffer=false] - enables drawing buffer preservation, enable this if you
     *  need to call toDataUrl on the webgl context
     * @param [options.backgroundColor=0x000000] - The background color of the rendered area
     *  (shown if not transparent).
     * @param [options.clearBeforeRender=true] - This sets if the renderer will clear the canvas or
     *   not before the new render pass.
     * @param [options.resolution=1] - The resolution / device pixel ratio of the renderer, retina would be 2
     * @param [options.forceCanvas=false] - prevents selection of WebGL renderer, even if such is present
     * @param [options.roundPixels=false] - If true PixiJS will Math.floor() x/y values when rendering,
     *  stopping pixel interpolation.
     * @param [options.forceFXAA=false] - forces FXAA antialiasing to be used over native.
     *  FXAA is faster, but may not always look as great **webgl only**
     * @param [options.legacy=false] - `true` to ensure compatibility with older / less advanced devices.
     *  If you experience unexplained flickering try setting this to true. **webgl only**
     * @param [options.powerPreference] - Parameter passed to webgl context, set to "high-performance"
     *  for devices with dual graphics card **webgl only**
     * @return Returns WebGL renderer if available, otherwise CanvasRenderer
     */
    function autoDetectRenderer(options?: PIXI.RendererOptions): PIXI.WebGLRenderer | PIXI.CanvasRenderer;
    const loader: PIXI.loaders.Loader;

    //////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////SETTINGS///////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    /**
     * User"s customizable globals for overriding the default PIXI settings, such
     * as a renderer"s default resolution, framerate, float percision, etc.
     * @example
     * // Use the native window resolution as the default resolution
     * // will support high-density displays when rendering
     * PIXI.settings.RESOLUTION = window.devicePixelRatio.
     *
     * // Disable interpolation when scaling, will make texture be pixelated
     * PIXI.settings.SCALE_MODE = PIXI.SCALE_MODES.NEAREST;
     */
    namespace settings {
        /**
         * Target frames per millisecond.
         * @default 0.06
         */
        let TARGET_FPMS: number;
        /**
         * If set to true WebGL will attempt make textures mimpaped by default.
         * Mipmapping will only succeed if the base texture uploaded has power of two dimensions.
         * @default true
         */
        let MIPMAP_TEXTURES: boolean;
        /**
         * If set to true WebGL will attempt make textures mimpaped by default.
         * Mipmapping will only succeed if the base texture uploaded has power of two dimensions.
         * @default true
         */
        let RESOLUTION: number;
        /**
         * Default filter resolution.
         * @default 1
         */
        let FILTER_RESOLUTION: number;
        /**
         * The maximum textures that this device supports.
         * @default 32
         */
        let SPRITE_MAX_TEXTURES: number;
        /**
         * The default sprite batch size.
         *
         * The default aims to balance desktop and mobile devices.
         * @default 4096
         */
        let SPRITE_BATCH_SIZE: number;
        /**
         * The prefix that denotes a URL is for a retina asset.
         * @example `@2x`
         * @default /@([0-9\.]+)x/
         */
        let RETINA_PREFIX: RegExp;
        /**
         * The default render options if none are supplied to {@link PIXI.WebGLRenderer}
         * or {@link PIXI.CanvasRenderer}.
         *
         * @static
         * @constant
         * @memberof PIXI.settings
         * @type {object}
         * @property {HTMLCanvasElement} view=null
         * @property {number} resolution=1
         * @property {boolean} antialias=false
         * @property {boolean} forceFXAA=false
         * @property {boolean} autoResize=false
         * @property {boolean} transparent=false
         * @property {number} backgroundColor=0x000000
         * @property {boolean} clearBeforeRender=true
         * @property {boolean} preserveDrawingBuffer=false
         * @property {boolean} roundPixels=false
         * @property {number} width=800
         * @property {number} height=600
         * @property {boolean} legacy=false
         */
        const RENDER_OPTIONS: {
            view: HTMLCanvasElement | null;
            antialias: boolean;
            forceFXAA: boolean;
            autoResize: boolean;
            transparent: boolean;
            backgroundColor: number;
            clearBeforeRender: boolean;
            preserveDrawingBuffer: boolean;
            roundPixels: boolean;
            width: number;
            height: number;
            legacy: boolean;
        };
        /**
         * Default transform type.
         * @type {PIXI.TRANSFORM_MODE}
         * @default PIXI.TRANSFORM_MODE.STATIC
         */
        let TRANSFORM_MODE: number;
        /**
         * Default Garbage Collection mode.
         * @type {PIXI.GC_MODES}
         * @default PIXI.GC_MODES.AUTO
         */
        let GC_MODE: number;
        /**
         * Default Garbage Collection max idle.
         * @default 3600
         */
        let GC_MAX_IDLE: number;
        /**
         * Default Garbage Collection maximum check count.
         * @default 600
         */
        let GC_MAX_CHECK_COUNT: number;
        /**
         * Default wrap modes that are supported by pixi.
         * @type {PIXI.WRAP_MODES}
         * @default PIXI.WRAP_MODES.CLAMP
         */
        let WRAP_MODE: number;
        /**
         * The scale modes that are supported by pixi.
         * @type {PIXI.SCALE_MODES}
         * @default PIXI.SCALE_MODES.LINEAR
         */
        let SCALE_MODE: number;
        /**
         * Default specify float precision in vertex shader.
         * @type {PIXI.PRECISION}
         * @default PIXI.PRECISION.HIGH
         */
        let PRECISION_VERTEX: string;
        /**
         * Default specify float precision in fragment shader.
         * @type {PIXI.PRECISION}
         * @default PIXI.PRECISION.MEDIUM
         */
        let PRECISION_FRAGMENT: string;
        /**
         * @deprecated since version 4.4.0
         */
        let PRECISION: string;
        /**
         * Default number of uploads per frame using prepare plugin.
         * @default 4
         */
        let UPLOADS_PER_FRAME: number;
        /**
         * Can we upload the same buffer in a single frame?
         */
        let CAN_UPLOAD_SAME_BUFFER: boolean;
        /**
         * Default Mesh `canvasPadding`.
         * @see PIXI.mesh.Mesh#canvasPadding
         */
        let MESH_CANVAS_PADDING: number;
    }

    //////////////////////////////////////////////////////////////////////////////
    /////////////////////////////ACCESSIBILITY////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    namespace accessibility {
        // accessibility
        class AccessibilityManager {
            constructor(renderer: CanvasRenderer | WebGLRenderer);
            activate(): void;
            deactivate(): void;
            protected div: HTMLElement;
            protected pool: HTMLElement[];
            protected renderId: number;
            debug: boolean;
            renderer: SystemRenderer;
            protected children: AccessibleTarget[];
            protected isActive: boolean;

            protected updateAccessibleObjects(displayObject: DisplayObject): void;
            protected update(): void;
            protected capHitArea(hitArea: HitArea): void;
            protected addChild(displayObject: DisplayObject): void;
            protected _onClick(e: interaction.InteractionEvent): void;
            protected _onFocus(e: interaction.InteractionEvent): void;
            protected _onFocusOut(e: interaction.InteractionEvent): void;
            protected _onKeyDown(e: interaction.InteractionEvent): void;
            protected _onMouseMove(e: MouseEvent): void;

            destroy(): void;
        }
        interface AccessibleTarget {
            accessible: boolean;
            accessibleTitle: string | null;
            accessibleHint: string | null;
            tabIndex: number;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////CORE//////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    // const

    namespace CONST {
        /** String of the current PIXI version. */
        const VERSION: string;
        /** Two Pi. */
        const PI_2: number;
        /** Conversion factor for converting radians to degrees. */
        const RAD_TO_DEG: number;
        /** Conversion factor for converting degrees to radians. */
        const DEG_TO_RAD: number;
        const TARGET_FPMS: number;
        /** Constant to identify the Renderer Type. */
        const RENDERER_TYPE: {
            /** Unknown render type. */
            UNKNOWN: number;
            /** WebGL render type. */
            WEBGL: number;
            /** Canvas render type. */
            CANVAS: number;
        };
        /**
         * Various blend modes supported by PIXI.
         *
         * IMPORTANT - The WebGL renderer only supports the NORMAL, ADD, MULTIPLY and SCREEN blend modes.
         * Anything else will silently act like NORMAL.
         */
        const BLEND_MODES: {
            NORMAL: number;
            ADD: number;
            MULTIPLY: number;
            SCREEN: number;
            OVERLAY: number;
            DARKEN: number;
            LIGHTEN: number;
            COLOR_DODGE: number;
            COLOR_BURN: number;
            HARD_LIGHT: number;
            SOFT_LIGHT: number;
            DIFFERENCE: number;
            EXCLUSION: number;
            HUE: number;
            SATURATION: number;
            COLOR: number;
            LUMINOSITY: number;
            NORMAL_NPM: number;
            ADD_NPM: number;
            SCREEN_NPM: number;
        };
        /**
         * Various webgl draw modes. These can be used to specify which GL drawMode to use
         * under certain situations and renderers.
         */
        const DRAW_MODES: {
            POINTS: number;
            LINES: number;
            LINE_LOOP: number;
            LINE_STRIP: number;
            TRIANGLES: number;
            TRIANGLE_STRIP: number;
            TRIANGLE_FAN: number;
        };
        /**
         * The scale modes that are supported by pixi.
         *
         * The {@link PIXI.settings.SCALE_MODE} scale mode affects the default scaling mode of future operations.
         * It can be re-assigned to either LINEAR or NEAREST, depending upon suitability.
         */
        const SCALE_MODES: {
            LINEAR: number;
            NEAREST: number;
        };
        /**
         * The gc modes that are supported by pixi.
         *
         * The {@link PIXI.settings.GC_MODE} Garbage Collection mode for PixiJS textures is AUTO
         * If set to GC_MODE, the renderer will occasionally check textures usage. If they are not
         * used for a specified period of time they will be removed from the GPU. They will of course
         * be uploaded again when they are required. This is a silent behind the scenes process that
         * should ensure that the GPU does not  get filled up.
         *
         * Handy for mobile devices!
         * This property only affects WebGL.
         */
        const GC_MODES: {
            /** Garbage collection will happen periodically automatically */
            AUTO: number;
            /** Garbage collection will need to be called manually */
            MANUAL: number;
        };
        const WRAP_MODES: {
            /** The textures uvs are clamped */
            CLAMP: number;
            /** The texture uvs tile and repeat */
            MIRRORED_REPEAT: number;
            /** The texture uvs tile and repeat with mirroring */
            REPEAT: number;
        };
        /**
         * Constants that specify the transform type.
         */
        const TRANSFORM_MODE: {
            DEFAULT: number;
            DYNAMIC: number;
            STATIC: number;
        };
        /**
         * Regexp for image type by extension.
         *
         * @example `image.png`
         */
        const URL_FILE_EXTENSION: RegExp | string;
        /**
         * Regexp for data URI.
         * Based on: {@link https://github.com/ragingwind/data-uri-regex}
         *
         * @example data:image/png;base64
         */
        const DATA_URI: RegExp | string;
        /**
         * Regexp for SVG size.
         *
         * @example <svg width="100" height="100"></svg>;
         */
        const SVG_SIZE: RegExp | string;
        /**
         * Constants that identify shapes, mainly to prevent `instanceof` calls.
         */
        const SHAPES: {
            /** Polygon */
            POLY: number;
            /** Rectangle */
            RECT: number;
            /** Circle */
            CIRC: number;
            /** Ellipse */
            ELIP: number;
            /** Rounded Rectangle */
            RREC: number;
        };
        /**
         * Constants that specify float precision in shaders.
         */
        const PRECISION: {
            /** "lowp" */
            LOW: string;
            /** "mediump" */
            MEDIUM: string;
            /** "highp" */
            HIGH: string;
        };
        /**
         * Constants that define the type of gradient on text.
         */
        const TEXT_GRADIENT: {
            /** Vertical gradient */
            LINEAR_VERTICAL: number;
            /** Linear gradient */
            LINEAR_HORIZONTAL: number;
        };
        /**
         * Represents the update priorities used by internal PIXI classes when registered with
         * the {@link PIXI.ticker.Ticker} object. Higher priority items are updated first and lower
         * priority items, such as render, should go later.
         */
        const UPDATE_PRIORITY: {
            /** INTERACTION=50 Highest priority, used for {@link PIXI.interaction.InteractionManager} */
            INTERACTION: number;
            /** HIGH=25 High priority updating, {@link PIXI.VideoBaseTexture} and {@link PIXI.extras.AnimatedSprite} */
            HIGH: number;
            /** NORMAL=0 Default priority for ticker events, see {@link PIXI.ticker.Ticker#add}. */
            NORMAL: number;
            /** LOW=-25 Low priority used for {@link PIXI.Application} rendering. */
            LOW: number;
            /** UTILITY=-50 Lowest priority used for {@link PIXI.prepare.BasePrepare} utility. */
            UTILITY: number;
        };
    }

    // display

    interface StageOptions {
        children?: boolean;
        texture?: boolean;
        baseTexture?: boolean;
    }

    /**
     * Convenience class to create a new PIXI application.
     * This class automatically creates the renderer, ticker
     * and root container.
     *
     * @example
     * // Create the application
     * const app = new PIXI.Application();
     *
     * // Add the view to the DOM
     * document.body.appendChild(app.view);
     *
     * // ex, add display objects
     * app.stage.addChild(PIXI.Sprite.fromImage("something.png"));
     */
    class Application {
        constructor(options?: ApplicationOptions);
        constructor(
            width?: number,
            height?: number,
            options?: ApplicationOptions,
            noWebGL?: boolean,
            sharedTicker?: boolean,
            sharedLoader?: boolean
        );

        private _ticker: ticker.Ticker;

        renderer: PIXI.WebGLRenderer | PIXI.CanvasRenderer;
        stage: Container;
        ticker: ticker.Ticker;
        /**
         * Loader instance to help with asset loading.
         */
        loader: loaders.Loader;
        readonly screen: Rectangle;

        /**
         * Convenience method for stopping the render.
         */
        stop(): void;
        /**
         * Convenience method for starting the render.
         */
        start(): void;
        /**
         * Render the current stage.
         */
        render(): void;
        /**
         * Destroy and don"t use after this.
         * @param [removeView=false] Automatically remove canvas from DOM.
         * @param [stageOptions] - Options parameter. A boolean will act as if all options
         *  have been set to that value
         */
        destroy(removeView?: boolean, stageOptions?: StageOptions | boolean): void;
        readonly view: HTMLCanvasElement;
    }

    interface DestroyOptions {
        /** if set to true, all the children will have their destroy method called as well. "options" will be passed on to those calls. */
        children?: boolean;
        /**
         * It Should it destroy the current texture of the sprite as well
         *
         * Only used for child Sprites if options.children is set to true
         */
        texture?: boolean;
        /**
         * Should it destroy the base texture of the sprite as well
         *
         * Only used for child Sprites if options.children is set to true
         */
        baseTexture?: boolean;
    }
    /**
     * "Builder" pattern for bounds rectangles
     * Axis-Aligned Bounding Box
     * It is not a shape! Its mutable thing, no "EMPTY" or that kind of problems
     */
    class Bounds {
        minX: number;
        minY: number;
        maxX: number;
        maxY: number;
        rect: Rectangle;

        /**
         * Checks if bounds are empty.
         *
         * @return True if empty.
         */
        isEmpty(): boolean;
        /**
         * Clears the bounds and resets.
         *
         */
        clear(): void;

        /**
         * Can return Rectangle.EMPTY constant, either construct new rectangle, either use your rectangle
         * It is not guaranteed that it will return tempRect
         *
         * @param rect - temporary object will be used if AABB is not empty
         * @returns A rectangle of the bounds
         */
        getRectangle(rect?: Rectangle): Rectangle;
        /**
         * This function should be inlined when its possible.
         *
         * @param point - The point to add.
         */
        addPoint(point: Point): void;
        /**
         * Adds a quad, not transformed
         *
         * @param vertices - The verts to add.
         */
        addQuad(vertices: ArrayLike<number>): Bounds | undefined;
        /**
         * Adds sprite frame, transformed.
         *
         * @param transform - TODO
         * @param x0 - TODO
         * @param y0 - TODO
         * @param x1 - TODO
         * @param y1 - TODO
         */
        addFrame(transform: Transform, x0: number, y0: number, x1: number, y1: number): void;
        /**
         * Add an array of vertices
         *
         * @param transform - TODO
         * @param vertices - TODO
         * @param beginOffset - TODO
         * @param endOffset - TODO
         */
        addVertices(transform: Transform, vertices: ArrayLike<number>, beginOffset: number, endOffset: number): void;
        /**
         * Adds other Bounds
         *
         * @param bounds - TODO
         */
        addBounds(bounds: Bounds): void;
        /**
         * Adds other Bounds, masked with Bounds
         *
         * @param bounds - TODO
         * @param mask - TODO
         */
        addBoundsMask(bounds: Bounds, mask: Bounds): void;
        /**
         * Adds other Bounds, masked with Rectangle
         *
         * @param bounds - TODO
         * @param area - TODO
         */
        addBoundsArea(bounds: Bounds, area: Rectangle): void;
    }
    /**
     * A Container represents a collection of display objects.
     *
     * It is the base class of all display objects that act as a container for other objects.
     *
     * ```js
     *  let container = new PIXI.Container();
     *  container.addChild(sprite);
     *  ```
     */
    class Container extends DisplayObject {
        // begin extras.getChildByName
        /**
         * Returns the display object in the container
         *
         * @param name - instance name
         * @return The child with the specified name.
         */
        getChildByName<T extends DisplayObject = Container>(name: string): T;
        // end extras.getChildByName

        children: DisplayObject[];
        width: number;
        height: number;

        protected onChildrenChange: (...args: any[]) => void;
        addChild<T extends DisplayObject>(...children: T[]): T;
        /**
         * Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
         *
         * @param child - The child to add
         * @param index - The index to place the child in
         * @return The child that was added.
         */
        addChildAt<T extends DisplayObject>(child: T, index: number): T;
        /**
         * Swaps the position of 2 Display Objects within this container.
         *
         * @param child - First display object to swap
         * @param child2 - Second display object to swap
         */
        swapChildren(child: DisplayObject, child2: DisplayObject): void;
        /**
         * Returns the index position of a child DisplayObject instance
         *
         * @param child - The DisplayObject instance to identify
         * @return The index position of the child display object to identify
         */
        getChildIndex(child: DisplayObject): number;
        /**
         * Changes the position of an existing child in the display object container
         *
         * @param child - The child DisplayObject instance for which you want to change the index number
         * @param index - The resulting index number for the child display object
         */
        setChildIndex(child: DisplayObject, index: number): void;
        /**
         * Returns the child at the specified index
         *
         * @param index - The index to get the child at
         * @return The child at the given index, if any.
         */
        getChildAt<T extends DisplayObject = Container>(index: number): T;
        removeChild<T extends DisplayObject = Container>(child: DisplayObject): T;
        /**
         * Removes a child from the specified index position.
         *
         * @param index - The index to get the child from
         * @return The child that was removed.
         */
        removeChildAt<T extends DisplayObject = Container>(index: number): T;
        /**
         * Removes all children from this container that are within the begin and end indexes.
         *
         * @param [beginIndex=0] - The beginning position.
         * @param [endIndex=this.children.length] - The ending position. Default value is size of the container.
         * @returns List of removed children
         */
        removeChildren<T extends DisplayObject = Container>(beginIndex?: number, endIndex?: number): T[];
        /**
         * Updates the transform on all children of this container for rendering
         */
        updateTransform(): void;
        /**
         * Recalculates the bounds of the container.
         */
        calculateBounds(): void;
        /**
         * Recalculates the bounds of the object. Override this to
         * calculate the bounds of the specific object (not including children).
         *
         */
        protected _calculateBounds(): void;
        protected containerUpdateTransform(): void;
        renderWebGL(renderer: WebGLRenderer): void;
        renderAdvancedWebGL(renderer: WebGLRenderer): void;
        protected _renderWebGL(renderer: WebGLRenderer): void;
        protected _renderCanvas(renderer: CanvasRenderer): void;
        renderCanvas(renderer: CanvasRenderer): void;
        /**
         * Removes all internal references and listeners as well as removes children from the display list.
         * Do not use a Container after calling `destroy`.
         *
         * @param [options] - Options parameter. A boolean will act as if all options have been set to that value
         */
        destroy(options?: DestroyOptions | boolean): void;

        once(
            event: interaction.InteractionEventTypes | "added" | "removed",
            fn: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
        once(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
        on(
            event: interaction.InteractionEventTypes | "added" | "removed",
            fn: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
        on(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
        off(event: "added" | "removed" | string | symbol, fn?: (...args: any[]) => any, context?: any): this;
    }
    /**
     * The base class for all objects that are rendered on the screen.
     * This is an abstract class and should not be used on its own rather it should be extended.
     */
    class DisplayObject extends utils.EventEmitter
        implements interaction.InteractiveTarget, accessibility.AccessibleTarget {
        // begin extras.cacheAsBitmap
        protected _cacheAsBitmap: boolean;
        protected _cacheData: boolean;
        /**
         * Set this to true if you want this display object to be cached as a bitmap.
         * This basically takes a snap shot of the display object as it is at that moment. It can
         * provide a performance benefit for complex static displayObjects.
         * To remove simply set this property to "false"
         *
         * IMPORTANT GOTCHA - make sure that all your textures are preloaded BEFORE setting this property to true
         * as it will take a snapshot of what is currently there. If the textures have not loaded then they will not appear.
         */
        cacheAsBitmap: boolean;
        protected _renderCachedWebGL(renderer: WebGLRenderer): void;
        protected _initCachedDisplayObject(renderer: WebGLRenderer): void;
        protected _renderCachedCanvas(renderer: CanvasRenderer): void;
        protected _initCachedDisplayObjectCanvas(renderer: CanvasRenderer): void;
        protected _calculateCachedBounds(): Rectangle;
        protected _getCachedLocalBounds(): Rectangle;
        protected _destroyCachedDisplayObject(): void;
        protected _cacheAsBitmapDestroy(options: boolean | any): void;
        // end extras.cacheAsBitmap

        // begin extras.getChildByName
        /**
         * The instance name of the object.
         */
        name: string | null;
        // end extras.getChildByName

        // begin extras.getGlobalPosition
        /**
         * Returns the global position of the displayObject. Does not depend on object scale, rotation and pivot.
         *
         * @param point - the point to write the global value to. If null a new point will be returned
         * @param skipUpdate - setting to true will stop the transforms of the scene graph from
         *  being updated. This means the calculation returned MAY be out of date BUT will give you a
         *  nice performance boost
         * @return The updated point
         */
        getGlobalPosition(point?: Point, skipUpdate?: boolean): Point;
        // end extras.getGlobalPosition

        // begin accessible target
        accessible: boolean;
        accessibleTitle: string | null;
        accessibleHint: string | null;
        tabIndex: number;
        // end accessible target

        // begin interactive target
        interactive: boolean;
        interactiveChildren: boolean;
        hitArea: PIXI.Rectangle | PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.RoundedRectangle | PIXI.HitArea;
        buttonMode: boolean;
        cursor: string;
        trackedPointers: { [key: number]: interaction.InteractionTrackingData };
        // Deprecated
        /** @deprecated */
        defaultCursor: string;
        // end interactive target

        transform: TransformBase;
        alpha: number;
        visible: boolean;
        renderable: boolean;
        parent: Container;
        worldAlpha: number;
        filterArea: Rectangle | null;
        protected _filters: Array<Filter<any>> | null;
        protected _enabledFilters: Array<Filter<any>> | null;
        protected _bounds: Bounds;
        protected _boundsID: number;
        protected _lastBoundsID: number;
        protected _boundsRect: Rectangle;
        protected _localBoundsRect: Rectangle;
        protected _mask: PIXI.Graphics | PIXI.Sprite | null;
        protected readonly _destroyed: boolean;
        x: number;
        y: number;
        worldTransform: Matrix;
        localTransform: Matrix;
        position: Point | ObservablePoint;
        scale: Point | ObservablePoint;
        pivot: Point | ObservablePoint;
        skew: ObservablePoint;
        rotation: number;
        worldVisible: boolean;
        mask: PIXI.Graphics | PIXI.Sprite | null;
        filters: Array<Filter<any>> | null;

        /**
         * Updates the object transform for rendering
         *
         * TODO - Optimization pass!
         */
        updateTransform(): void;
        protected displayObjectUpdateTransform(): void;
        /**
         * recursively updates transform of all objects from the root to this one
         * internal function for toLocal()
         */
        protected _recursivePostUpdateTransform(): void;
        /**
         * Retrieves the bounds of the displayObject as a rectangle object.
         *
         * @param skipUpdate - setting to true will stop the transforms of the scene graph from
         *  being updated. This means the calculation returned MAY be out of date BUT will give you a
         *  nice performance boost
         * @param rect - Optional rectangle to store the result of the bounds calculation
         * @return the rectangular bounding area
         */
        getBounds(skipUpdate?: boolean, rect?: Rectangle): Rectangle;
        /**
         * Retrieves the local bounds of the displayObject as a rectangle object
         *
         * @param [rect] - Optional rectangle to store the result of the bounds calculation
         * @return the rectangular bounding area
         */
        getLocalBounds(rect?: Rectangle): Rectangle;
        /**
         * Calculates the global position of the display object
         *
         * @param position - The world origin to calculate from
         * @param [point] - A Point object in which to store the value, optional
         *  (otherwise will create a new Point)
         * @param [skipUpdate=false] - Should we skip the update transform.
         * @return A point object representing the position of this object
         */
        toGlobal(position: PointLike): Point;
        /**
         * Calculates the global position of the display object
         *
         * @param position - The world origin to calculate from
         * @param [point] - A Point object in which to store the value, optional
         *  (otherwise will create a new Point)
         * @param [skipUpdate=false] - Should we skip the update transform.
         * @return A point object representing the position of this object
         */
        toGlobal<T extends PointLike>(position: PointLike, point?: T, skipUpdate?: boolean): T;
        //creates and returns a new point
        toLocal(position: PointLike, from?: DisplayObject): Point;
        /**
         * Calculates the local position of the display object relative to another point
         *
         * @param position - The world origin to calculate from
         * @param [from] - The DisplayObject to calculate the global position from
         * @param [point] - A Point object in which to store the value, optional
         *  (otherwise will create a new Point)
         * @param [skipUpdate=false] - Should we skip the update transform
         * @return A point object representing the position of this object
         */
        toLocal<T extends PointLike>(position: PointLike, from?: DisplayObject, point?: T, skipUpdate?: boolean): T;
        /**
         * Renders the object using the WebGL renderer
         *
         * @param renderer - The renderer
         */
        renderWebGL(renderer: WebGLRenderer): void;
        renderCanvas(renderer: CanvasRenderer): void;
        setParent(container: Container): Container;
        /**
         * Convenience function to set the position, scale, skew and pivot at once.
         *
         * @param [x=0] - The X position
         * @param [y=0] - The Y position
         * @param [scaleX=1] - The X scale value
         * @param [scaleY=1] - The Y scale value
         * @param [rotation=0] - The rotation
         * @param [skewX=0] - The X skew value
         * @param [skewY=0] - The Y skew value
         * @param [pivotX=0] - The X pivot value
         * @param [pivotY=0] - The Y pivot value
         * @return The DisplayObject instance
         */
        setTransform(
            x?: number,
            y?: number,
            scaleX?: number,
            scaleY?: number,
            rotation?: number,
            skewX?: number,
            skewY?: number,
            pivotX?: number,
            pivotY?: number
        ): DisplayObject;
        /**
         * Base destroy method for generic display objects. This will automatically
         * remove the display object from its parent Container as well as remove
         * all current event listeners and internal references. Do not use a DisplayObject
         * after calling `destroy`.
         */
        destroy(): void;

        on(
            event: interaction.InteractionEventTypes,
            fn: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
        on(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
        once(
            event: interaction.InteractionEventTypes,
            fn: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
        once(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
        removeListener(
            event: interaction.InteractionEventTypes,
            fn?: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
        removeAllListeners(event?: interaction.InteractionEventTypes): this;
        off(
            event: interaction.InteractionEventTypes,
            fn?: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
        addListener(
            event: interaction.InteractionEventTypes,
            fn: (event: interaction.InteractionEvent) => void,
            context?: any
        ): this;
    }
    /**
     * Generic class to deal with traditional 2D matrix transforms
     */
    class TransformBase {
        static IDENTITY: TransformBase;

        worldTransform: Matrix;
        localTransform: Matrix;
        protected _worldID: number;
        protected _parentID: number;
        /**
         * Updates only local matrix
         */
        updateLocalTransform(): void;
        /**
         * Updates the values of the object and applies the parent"s transform.
         *
         * @param parentTransform - The transform of the parent of this object
         */
        updateTransform(parentTransform: TransformBase): void;
        updateWorldTransform(parentTransform: TransformBase): void;
    }
    /**
     * Transform that takes care about its versions
     */
    class TransformStatic extends TransformBase {
        position: ObservablePoint;
        scale: ObservablePoint;
        pivot: ObservablePoint;
        skew: ObservablePoint;

        protected _rotation: number;
        protected _sr?: number;
        protected _cr?: number;
        protected _cy?: number;
        protected _sy?: number;
        protected _sx?: number;
        protected _cx?: number;
        protected _localID: number;
        protected _currentLocalID: number;

        protected onChange(): void;
        updateSkew(): void;
        /**
         * Decomposes a matrix and sets the transforms properties based on it.
         *
         * @param matrix - The matrix to decompose
         */
        setFromMatrix(matrix: Matrix): void;
        rotation: number;
    }
    /**
     * Generic class to deal with traditional 2D matrix transforms
     * local transformation is calculated from position,scale,skew and rotation
     */
    class Transform extends TransformBase {
        constructor();

        position: Point;
        scale: Point;
        skew: ObservablePoint;
        pivot: Point;

        protected _rotation: number;
        protected _sr?: number;
        protected _cr?: number;
        protected _cy?: number;
        protected _sy?: number;
        protected _sx?: number;
        protected _cx?: number;

        updateSkew(): void;
        /**
         * Decomposes a matrix and sets the transforms properties based on it.
         *
         * @param matrix - The matrix to decompose
         */
        setFromMatrix(matrix: Matrix): void;

        rotation: number;
    }
    // graphics
    /**
     * A GraphicsData object.
     */
    class GraphicsData {
        constructor(
            lineWidth: number,
            lineColor: number,
            lineAlpha: number,
            fillColor: number,
            fillAlpha: number,
            fill: boolean,
            nativeLines: boolean,
            shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any,
            lineAlignment?: number
        );
        lineWidth: number;
        lineAlignment: number;
        nativeLines: boolean;
        lineColor: number;
        lineAlpha: number;
        protected _lineTint: number;
        fillColor: number;
        fillAlpha: number;
        protected _fillTint: number;
        fill: boolean;
        protected holes: Circle[] | Rectangle[] | Ellipse[] | Polygon[] | RoundedRectangle[] | any[];
        shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any;
        type?: number;
        /**
         * Creates a new GraphicsData object with the same values as this one.
         *
         * @return Cloned GraphicsData object
         */
        clone(): GraphicsData;
        /**
         * Adds a hole to the shape.
         *
         * @param shape - The shape of the hole.
         */
        addHole(shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any): void;
        /**
         * Destroys the Graphics data.
         */
        destroy(options?: DestroyOptions | boolean): void;
    }
    /**
     * The Graphics class contains methods used to draw primitive shapes such as lines, circles and
     * rectangles to the display, and to color and fill them.
     */
    class Graphics extends Container {
        /**
         * Graphics curves resolution settings. If `adaptive` flag is set to `true`,
         * the resolution is calculated based on the curve"s length to ensure better visual quality.
         * Adaptive draw works with `bezierCurveTo` and `quadraticCurveTo`.
         *
         * @property {boolean} adaptive=false - flag indicating if the resolution should be adaptive
         * @property {number} maxLength=10 - maximal length of a single segment of the curve (if adaptive = false, ignored)
         * @property {number} minSegments=8 - minimal number of segments in the curve (if adaptive = false, ignored)
         * @property {number} maxSegments=2048 - maximal number of segments in the curve (if adaptive = false, ignored)
         */
        static CURVES: {
            adaptive: boolean;
            maxLength: number;
            minSegments: number;
            maxSegments: number;
        };

        constructor(nativeLines?: boolean);

        /**
         * When cacheAsBitmap is set to true the graphics object will be rendered as if it was a sprite.
         * This is useful if your graphics element does not change often, as it will speed up the rendering
         * of the object in exchange for taking up texture memory. It is also useful if you need the graphics
         * object to be anti-aliased, because it will be rendered using canvas. This is not recommended if
         * you are constantly redrawing the graphics element.
         *
         * @default false
         */
        cacheAsBitmap: boolean;
        fillAlpha: number;
        lineWidth: number;
        nativeLines: boolean;
        lineColor: number;
        lineAlignment: number;
        protected graphicsData: GraphicsData[];
        tint: number;
        protected _prevTint: number;
        blendMode: number;
        currentPath: GraphicsData;
        protected _webGL: any;
        isMask: boolean;
        boundsPadding: number;
        protected _localBounds: Bounds;
        dirty: number;
        canvasTintDirty: number;
        fastRectDirty: number;
        clearDirty: number;
        boundsDirty: number;
        protected cachedSpriteDirty: boolean;
        protected _spriteRect: Rectangle;
        protected _fastRect: boolean;

        static _SPRITE_TEXTURE: Texture;

        clone(): Graphics;
        protected _quadraticCurveLength(
            fromX: number,
            fromY: number,
            cpX: number,
            cpY: number,
            toX: number,
            toY: number
        ): number;
        protected _bezierCurveLength(
            fromX: number,
            fromY: number,
            cpX: number,
            cpY: number,
            cpX2: number,
            cpY2: number,
            toX: number,
            toY: number
        ): number;
        protected _segmentsCount(length: number): number;
        lineStyle(lineWidth?: number, color?: number, alpha?: number, alignment?: number): Graphics;
        moveTo(x: number, y: number): Graphics;
        lineTo(x: number, y: number): Graphics;
        quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): Graphics;
        bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): Graphics;
        arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics;
        arc(
            cx: number,
            cy: number,
            radius: number,
            startAngle: number,
            endAngle: number,
            anticlockwise?: boolean
        ): Graphics;
        beginFill(color: number, alpha?: number): Graphics;
        endFill(): Graphics;
        drawRect(x: number, y: number, width: number, height: number): Graphics;
        drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): Graphics;
        drawCircle(x: number, y: number, radius: number): Graphics;
        drawEllipse(x: number, y: number, width: number, height: number): Graphics;
        drawPolygon(path: number[] | Point[] | Polygon): Graphics;
        drawStar(
            x: number,
            y: number,
            points: number,
            radius: number,
            innerRadius: number,
            rotation?: number
        ): Graphics;
        clear(): Graphics;
        isFastRect(): boolean;
        protected _renderCanvas(renderer: CanvasRenderer): void;
        protected _calculateBounds(): Rectangle;
        protected _renderSpriteRect(renderer: PIXI.SystemRenderer): void;
        containsPoint(point: Point): boolean;
        updateLocalBounds(): void;
        drawShape(shape: Circle | Rectangle | Ellipse | Polygon | RoundedRectangle | any): GraphicsData;
        generateCanvasTexture(scaleMode?: number, resolution?: number): Texture;
        closePath(): Graphics;
        addHole(): Graphics;
        destroy(options?: DestroyOptions | boolean): void;
    }
    class CanvasGraphicsRenderer {
        constructor(renderer: SystemRenderer);
        render(graphics: Graphics): void;
        protected updateGraphicsTint(graphics: Graphics): void;
        protected renderPolygon(points: Point[], close: boolean, context: CanvasRenderingContext2D): void;
        destroy(): void;
    }
    /**
     * Renders the graphics object.
     */
    class GraphicsRenderer extends ObjectRenderer {
        constructor(renderer: PIXI.CanvasRenderer);

        protected graphicsDataPool: GraphicsData[];
        protected primitiveShader: PrimitiveShader;
        gl: WebGLRenderingContext;

        CONTEXT_UID: number;
        /**
         * Destroys this renderer.
         */
        destroy(): void;
        /**
         * Renders a graphics object.
         *
         * @param graphics - The graphics object to render.
         */
        render(graphics: Graphics): void;
        protected updateGraphics(graphics: PIXI.Graphics): void;
        getWebGLData(webGL: WebGLRenderingContext, type: number, nativeLines: number): WebGLGraphicsData;
    }
    class WebGLGraphicsData {
        constructor(gl: WebGLRenderingContext, shader: glCore.GLShader, attribsState: glCore.AttribState);

        gl: WebGLRenderingContext;
        color: number[];
        points: Point[];
        indices: number[];
        buffer: WebGLBuffer;
        indexBuffer: WebGLBuffer;
        dirty: boolean;
        glPoints: number[];
        glIndices: number[];
        shader: glCore.GLShader;
        vao: glCore.VertexArrayObject;
        nativeLines: boolean;

        reset(): void;
        upload(): void;
        destroy(): void;
    }
    /**
     * This shader is used to draw simple primitive shapes for {@link PIXI.Graphics}.
     */
    class PrimitiveShader extends glCore.GLShader {}

    // math

    /**
     * Implements Dihedral Group D_8, see [group D4]{@link http://mathworld.wolfram.com/DihedralGroupD4.html},
     * D8 is the same but with diagonals. Used for texture rotations.
     *
     * Vector xX(i), xY(i) is U-axis of sprite with rotation i
     * Vector yY(i), yY(i) is V-axis of sprite with rotation i
     * Rotations: 0 grad (0), 90 grad (2), 180 grad (4), 270 grad (6)
     * Mirrors: vertical (8), main diagonal (10), horizontal (12), reverse diagonal (14)
     * This is the small part of gameofbombs.com portal system. It works.
     *
     * @author Ivan @ivanpopelyshev
     * @class
     * @memberof PIXI
     */
    namespace GroupD8 {
        const E: number;
        const SE: number;
        const S: number;
        const SW: number;
        const W: number;
        const NW: number;
        const N: number;
        const NE: number;
        const MIRROR_HORIZONTAL: number;
        const MIRROR_VERTICAL: number;
        function uX(ind: number): number;
        function uY(ind: number): number;
        function vX(ind: number): number;
        function vY(ind: number): number;
        function inv(rotation: number): number;
        function add(rotationSecond: number, rotationFirst: number): number;
        function sub(rotationSecond: number, rotationFirst: number): number;
        /**
         * Adds 180 degrees to rotation. Commutative operation.
         *
         * @param rotation - The number to rotate.
         * @returns rotated number
         */
        function rotate180(rotation: number): number;
        /**
         * Direction of main vector can be horizontal, vertical or diagonal.
         * Some objects work with vertical directions different.
         *
         * @param rotation - The number to check.
         * @returns Whether or not the direction is vertical
         */
        function isVertical(rotation: number): boolean;
        /**
         * @param dx - TODO
         * @param dy - TODO
         *
         * @return TODO
         */
        function byDirection(dx: number, dy: number): number;
        /**
         * Helps sprite to compensate texture packer rotation.
         *
         * @param matrix - sprite world matrix
         * @param rotation - The rotation factor to use.
         * @param tx - sprite anchoring
         * @param ty - sprite anchoring
         */
        function matrixAppendRotationInv(matrix: Matrix, rotation: number, tx: number, ty: number): void;
    }
    /**
     * The PixiJS Matrix class as an object, which makes it a lot faster,
     * here is a representation of it :
     * | a | c | tx|
     * | b | d | ty|
     * | 0 | 0 | 1 |
     */
    class Matrix {
        constructor(a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number);

        a: number;
        b: number;
        c: number;
        d: number;
        tx: number;
        ty: number;

        /**
         * Creates a Matrix object based on the given array. The Element to Matrix mapping order is as follows:
         *
         * a = array[0]
         * b = array[1]
         * c = array[3]
         * d = array[4]
         * tx = array[2]
         * ty = array[5]
         *
         * @param {number[]} array - The array that the matrix will be populated from.
         */
        fromArray(array: number[]): void;
        /**
         * sets the matrix properties
         *
         * @param a - Matrix component
         * @param b - Matrix component
         * @param c - Matrix component
         * @param d - Matrix component
         * @param tx - Matrix component
         * @param ty - Matrix component
         *
         * @return This matrix. Good for chaining method calls.
         */
        set(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix;
        /**
         * Creates an array from the current Matrix object.
         *
         * @param transpose - Whether we need to transpose the matrix or not
         * @param [out=new Float32Array(9)] - If provided the array will be assigned to out
         * @return the newly created array which contains the matrix
         */
        toArray(transpose?: boolean, out?: number[]): number[];
        /**
         * Get a new position with the current transformation applied.
         * Can be used to go from a child"s coordinate space to the world coordinate space. (e.g. rendering)
         *
         * @param pos - The origin
         * @param [newPos] - The point that the new position is assigned to (allowed to be same as input)
         * @return The new point, transformed through this matrix
         */
        apply(pos: Point, newPos?: Point): Point;
        applyInverse(pos: Point, newPos?: Point): Point;
        translate(x: number, y: number): Matrix;
        scale(x: number, y: number): Matrix;
        rotate(angle: number): Matrix;
        append(matrix: Matrix): Matrix;
        setTransform(
            x: number,
            y: number,
            pivotX: number,
            pivotY: number,
            scaleX: number,
            scaleY: number,
            rotation: number,
            skewX: number,
            skewY: number
        ): PIXI.Matrix;
        prepend(matrix: Matrix): Matrix;
        invert(): Matrix;
        identity(): Matrix;
        decompose(transform: TransformBase): TransformBase;
        clone(): Matrix;
        copy(matrix: Matrix): Matrix;

        static IDENTITY: Matrix;
        static TEMP_MATRIX: Matrix;
    }
    class PointLike {
        x: number;
        y: number;

        set(x?: number, y?: number): void;
        copy(point: PointLike): void;
    }
    /**
     * The Point object represents a location in a two-dimensional coordinate system, where x represents
     * the horizontal axis and y represents the vertical axis.
     * An observable point is a point that triggers a callback when the point"s position is changed.
     */
    class ObservablePoint extends PointLike {
        constructor(cb: () => any, scope?: any, x?: number, y?: number);
        clone(cb?: Function, scope?: any): ObservablePoint;
        equals(p: Point | ObservablePoint | PointLike): boolean;
        cb: () => any;
        scope: any;
    }
    /**
     * The Point object represents a location in a two-dimensional coordinate system, where x represents
     * the horizontal axis and y represents the vertical axis.
     */
    class Point extends PointLike {
        constructor(x?: number, y?: number);
        clone(): Point;
        equals(p: PointLike): boolean;
    }
    interface HitArea {
        contains(x: number, y: number): boolean;
    }
    /**
     * The Circle object can be used to specify a hit area for displayObjects
     */
    class Circle implements HitArea {
        constructor(x?: number, y?: number, radius?: number);

        x: number;
        y: number;
        radius: number;
        type: number;

        clone(): Circle;
        contains(x: number, y: number): boolean;
        getBounds(): Rectangle;
    }
    /**
     * The Ellipse object can be used to specify a hit area for displayObjects
     */
    class Ellipse implements HitArea {
        constructor(x?: number, y?: number, halfWidth?: number, halfHeight?: number);

        x: number;
        y: number;
        width: number;
        height: number;
        type: number;

        clone(): Ellipse;
        contains(x: number, y: number): boolean;
        getBounds(): Rectangle;
    }
    class Polygon implements HitArea {
        constructor(points: Point[] | number[]);
        // Note - Rest Params cannot be combined with |
        //tslint:disable-next-line:unified-signatures
        constructor(...points: Point[]);
        //tslint:disable-next-line:unified-signatures
        constructor(...points: number[]);

        closed: boolean;
        points: number[];
        type: number;

        clone(): Polygon;
        contains(x: number, y: number): boolean;
        close(): void;
    }
    /**
     * Rectangle object is an area defined by its position, as indicated by its top-left corner
     * point (x, y) and by its width and its height.
     */
    class Rectangle implements HitArea {
        constructor(x?: number, y?: number, width?: number, height?: number);

        x: number;
        y: number;
        width: number;
        height: number;
        type: number;
        left: number;
        right: number;
        top: number;
        bottom: number;

        static EMPTY: Rectangle;

        /**
         * Creates a clone of this Rectangle
         *
         * @return a copy of the rectangle
         */
        clone(): Rectangle;
        /**
         * Enlarges rectangle that way its corners lie on grid
         *
         * @param [resolution=1] resolution
         * @param [eps=0.001] precision
         */
        ceil(resolution?: number, eps?: number): void;
        /**
         * Copies another rectangle to this one.
         *
         * @param rectangle - The rectangle to copy.
         * @return Returns itself.
         */
        copy(rectangle: Rectangle): Rectangle;
        /**
         * Checks whether the x and y coordinates given are contained within this Rectangle
         *
         * @param x - The X coordinate of the point to test
         * @param y - The Y coordinate of the point to test
         * @return Whether the x/y coordinates are within this Rectangle
         */
        contains(x: number, y: number): boolean;
        /**
         * Pads the rectangle making it grow in all directions.
         *
         * @param paddingX - The horizontal padding amount.
         * @param [paddingY] - The vertical padding amount.
         */
        pad(paddingX: number, paddingY: number): void;
        /**
         * Fits this rectangle around the passed one.
         *
         * @param rectangle - The rectangle to fit.
         */
        fit(rectangle: Rectangle): void;
        /**
         * Enlarges this rectangle to include the passed rectangle.
         *
         * @param rectangle - The rectangle to include.
         */
        enlarge(rectangle: Rectangle): void;
    }
    class RoundedRectangle implements HitArea {
        constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);

        x: number;
        y: number;
        width: number;
        height: number;
        radius: number;
        type: number;

        clone(): RoundedRectangle;
        contains(x: number, y: number): boolean;
    }
    // renderers
    interface RendererOptions {
        /**
         * the width of the renderers view [default=800]
         */
        width?: number;

        /**
         * the height of the renderers view [default=600]
         */
        height?: number;

        /**
         * the canvas to use as a view, optional
         */
        view?: HTMLCanvasElement;

        /**
         * If the render view is transparent, [default=false]
         */
        transparent?: boolean;

        /**
         * sets antialias (only applicable in chrome at the moment) [default=false]
         */
        antialias?: boolean;

        /**
         * enables drawing buffer preservation, enable this if you need to call toDataUrl on the webgl context [default=false]
         */
        preserveDrawingBuffer?: boolean;

        /**
         * The resolution / device pixel ratio of the renderer, retina would be 2 [default=1]
         */
        resolution?: number;

        /**
         * prevents selection of WebGL renderer, even if such is present [default=false]
         */
        forceCanvas?: boolean;

        /**
         * The background color of the rendered area (shown if not transparent) [default=0x000000]
         */
        backgroundColor?: number;

        /**
         * This sets if the renderer will clear the canvas or not before the new render pass. [default=true]
         */
        clearBeforeRender?: boolean;

        /**
         * If true Pixi will Math.floor() x/ y values when rendering, stopping pixel interpolation. [default=false]
         */
        roundPixels?: boolean;

        /**
         * forces FXAA antialiasing to be used over native FXAA is faster, but may not always look as great ** webgl only** [default=false]
         */
        forceFXAA?: boolean;

        /**
         * `true` to ensure compatibility with older / less advanced devices. If you experience unexplained flickering try setting this to true. **webgl only** [default=false]
         */
        legacy?: boolean;

        /**
         * Deprecated
         */
        context?: WebGLRenderingContext;

        /**
         * @deprecated
         */
        autoResize?: boolean;

        /**
         * Parameter passed to webgl context, set to "high-performance" for devices with dual graphics card
         */
        powerPreference?: "high-performance";
    }
    interface ApplicationOptions extends RendererOptions {
        /**
         * `true` to use PIXI.ticker.shared, `false` to create new ticker. [default=false]
         */
        sharedTicker?: boolean;

        /**
         * `true` to use PIXI.loaders.shared, `false` to create new Loader.
         */
        sharedLoader?: boolean;

        /**
         * automatically starts the rendering after the construction.
         * Note that setting this parameter to false does NOT stop the shared ticker even if you set
         * options.sharedTicker to true in case that it is already started. Stop it by your own.
         */
        autoStart?: boolean;
    }
    interface DefaultRendererPlugins {
        accessibility: accessibility.AccessibilityManager;
        interaction: interaction.InteractionManager;
    }
    interface RendererPlugins extends DefaultRendererPlugins {}
    /**
     * The SystemRenderer is the base for a PixiJS Renderer. It is extended by the {@link PIXI.CanvasRenderer}
     * and {@link PIXI.WebGLRenderer} which can be used for rendering a PixiJS scene.
     */
    class SystemRenderer extends utils.EventEmitter {
        constructor(system: string, options?: RendererOptions);
        constructor(system: string, screenWidth?: number, screenHeight?: number, options?: RendererOptions);

        type: number;
        options: RendererOptions;
        screen: Rectangle;
        readonly width: number;
        readonly height: number;
        view: HTMLCanvasElement;
        resolution: number;
        transparent: boolean;
        autoResize: boolean;
        blendModes: any; // todo?
        preserveDrawingBuffer: boolean;
        clearBeforeRender: boolean;
        roundPixels: boolean;
        backgroundColor: number;
        protected _backgroundColor: number;
        protected _backgroundColorRgba: number[];
        protected _backgroundColorString: string;
        protected _tempDisplayObjectParent: Container;
        protected _lastObjectRendered: DisplayObject;

        resize(screenWidth: number, screenHeight: number): void;
        generateTexture(
            displayObject: DisplayObject,
            scaleMode?: number,
            resolution?: number,
            region?: Rectangle
        ): RenderTexture;
        render(...args: any[]): void;
        destroy(removeView?: boolean): void;
    }
    interface DefaultCanvasRendererPlugins {
        extract: extract.CanvasExtract;
        prepare: prepare.CanvasPrepare;
    }
    interface CanvasRendererPlugins extends DefaultCanvasRendererPlugins, RendererPlugins {}
    /**
     * The CanvasRenderer draws the scene and all its content onto a 2d canvas. This renderer should
     * be used for browsers that do not support WebGL. Don"t forget to add the CanvasRenderer.view to
     * your DOM or you will not see anything :)
     */
    class CanvasRenderer extends SystemRenderer {
        // plugintarget mixin start
        static __plugins: {
            [pluginName: string]: { new (renderer: CanvasRenderer): any };
        };
        /**
         * Adds a plugin to the renderer.
         *
         * @param pluginName - The name of the plugin.
         * @param ctor - The constructor function or class for the plugin.
         */
        static registerPlugin(pluginName: string, ctor: { new (renderer: CanvasRenderer): any }): void;
        /**
         * Collection of installed plugins. These are included by default in PIXI, but can be excluded
         * by creating a custom build. Consult the README for more information about creating custom
         * builds and excluding plugins.
         *
         * @property {PIXI.accessibility.AccessibilityManager} accessibility Support tabbing interactive elements.
         * @property {PIXI.extract.CanvasExtract} extract Extract image data from renderer.
         * @property {PIXI.interaction.InteractionManager} interaction Handles mouse, touch and pointer events.
         * @property {PIXI.prepare.CanvasPrepare} prepare Pre-render display objects.
         */
        plugins: any;
        initPlugins(): void;
        destroyPlugins(): void;
        // plugintarget mixin end

        constructor(options?: RendererOptions);
        constructor(screenWidth?: number, screenHeight?: number, options?: RendererOptions);

        protected _activeBlendMode: number;
        rootContext: CanvasRenderingContext2D;
        rootResolution?: number;
        refresh: boolean;
        maskManager: CanvasMaskManager;
        smoothProperty: string;
        /**
         * Collection of methods for extracting data (image, pixels, etc.) from a display object or render texture
         */
        extract: extract.CanvasExtract;

        context: CanvasRenderingContext2D | null;

        render(
            displayObject: PIXI.DisplayObject,
            renderTexture?: PIXI.RenderTexture,
            clear?: boolean,
            transform?: PIXI.Matrix,
            skipUpdateTransform?: boolean
        ): void;
        setBlendMode(blendMode: number): void;
        destroy(removeView?: boolean): void;
        clear(clearColor?: string): void;
        invalidateBlendMode(): void;

        on(event: "prerender" | "postrender", fn: () => void, context?: any): this;
        once(event: "prerender" | "postrender", fn: () => void, context?: any): this;
        removeListener(event: "prerender" | "postrender", fn?: () => void, context?: any): this;
        removeAllListeners(event?: "prerender" | "postrender"): this;
        off(event: "prerender" | "postrender", fn?: () => void, context?: any): this;
        addListener(event: "prerender" | "postrender", fn: () => void, context?: any): this;
    }
    /**
     * A set of functions used to handle masking.
     */
    class CanvasMaskManager {
        constructor(renderer: CanvasRenderer);

        pushMask(maskData: any): void;
        protected renderGraphicsShape(graphics: Graphics): void;
        popMask(renderer: WebGLRenderer | CanvasRenderer): void;
        destroy(): void;
    }
    /**
     * Creates a Canvas element of the given size.
     */
    class CanvasRenderTarget {
        constructor(width: number, height: number, resolution: number);

        canvas: HTMLCanvasElement;
        context: CanvasRenderingContext2D;
        resolution: number;

        width: number;
        height: number;

        clear(): void;
        resize(width: number, height: number): void;
        destroy(): void;
    }

    interface WebGLRendererOptions extends RendererOptions {}
    interface DefaultWebGLRendererPlugins {
        extract: extract.WebGLExtract;
        prepare: prepare.WebGLPrepare;
    }
    interface WebGLRendererPlugins extends DefaultWebGLRendererPlugins, RendererPlugins {}
    interface WebGLRendererOptions extends RendererOptions {}
    /**
     * The WebGLRenderer draws the scene and all its content onto a webGL enabled canvas. This renderer
     * should be used for browsers that support webGL. This Render works by automatically managing webGLBatchs.
     * So no need for Sprite Batches or Sprite Clouds.
     * Don"t forget to add the view to your DOM or you will not see anything :)
     */
    class WebGLRenderer extends SystemRenderer {
        // plugintarget mixin start
        static __plugins: {
            [pluginName: string]: { new (renderer: WebGLRenderer): any };
        };
        /**
         * Adds a plugin to the renderer.
         */
        static registerPlugin(pluginName: string, ctor: { new (renderer: WebGLRenderer): any }): void;
        /**
         * Collection of installed plugins. These are included by default in PIXI, but can be excluded
         * by creating a custom build. Consult the README for more information about creating custom
         * builds and excluding plugins.
         * @property {PIXI.accessibility.AccessibilityManager} accessibility Support tabbing interactive elements.
         * @property {PIXI.extract.WebGLExtract} extract Extract image data from renderer.
         * @property {PIXI.interaction.InteractionManager} interaction Handles mouse, touch and pointer events.
         * @property {PIXI.prepare.WebGLPrepare} prepare Pre-render display objects.
         */
        plugins: any;
        initPlugins(): void;
        destroyPlugins(): void;
        // plugintarget mixin end

        constructor(options?: WebGLRendererOptions);
        constructor(screenWidth?: number, screenHeight?: number, options?: WebGLRendererOptions);

        protected _contextOptions: {
            alpha: boolean;
            antiAlias?: boolean;
            premultipliedAlpha: boolean;
            stencil: boolean;
            preseveDrawingBuffer?: boolean;
        };
        protected _backgroundColorRgba: number[];
        maskManager: MaskManager;
        stencilManager?: StencilManager;
        emptyRenderer: ObjectRenderer;
        currentRenderer: ObjectRenderer;
        gl: WebGLRenderingContext;
        CONTEXT_UID: number;
        state?: WebGLState;
        renderingToScreen: boolean;
        boundTextures: BaseTexture[];
        emptyTextures: BaseTexture[];
        protected _unknownBoundTextures: BaseTexture[];
        filterManager: FilterManager;
        textureManager?: TextureManager;
        textureGC?: TextureGarbageCollector;
        /**
         * Collection of methods for extracting data (image, pixels, etc.) from a display object or render texture
         */
        extract: extract.WebGLExtract;
        protected drawModes: any;
        protected _activeShader: Shader;
        _activeRenderTarget: RenderTarget;
        protected _initContext(): void;

        render(
            displayObject: PIXI.DisplayObject,
            renderTexture?: PIXI.RenderTexture,
            clear?: boolean,
            transform?: PIXI.Matrix,
            skipUpdateTransform?: boolean
        ): void;
        setObjectRenderer(objectRenderer: ObjectRenderer): void;
        flush(): void;
        setBlendMode(blendMode: number): void;
        clear(clearColor?: number): void;
        setTransform(matrix: Matrix): void;
        clearRenderTexture(renderTexture: RenderTexture, clearColor?: number): WebGLRenderer;
        bindRenderTexture(renderTexture: RenderTexture, transform: Matrix): WebGLRenderer;
        bindRenderTarget(renderTarget: RenderTarget): WebGLRenderer;
        bindShader(shader: Shader, autoProject?: boolean): WebGLRenderer;
        bindTexture(texture: Texture | BaseTexture, location?: number, forceLocation?: boolean): number;
        unbindTexture(texture: Texture | BaseTexture): WebGLRenderer | undefined;
        createVao(): glCore.VertexArrayObject;
        bindVao(vao: glCore.VertexArrayObject): WebGLRenderer;
        reset(): WebGLRenderer;
        handleContextLost: (event: WebGLContextEvent) => void;
        handleContextRestored: () => void;
        destroy(removeView?: boolean): void;

        on(event: "prerender" | "postrender", fn: () => void, context?: any): this;
        on(event: "context", fn: (gl: WebGLRenderingContext) => void, context?: any): this;
        once(event: "prerender" | "postrender", fn: () => void, context?: any): this;
        once(event: "context", fn: (gl: WebGLRenderingContext) => void, context?: any): this;
        removeListener(event: "prerender" | "postrender", fn?: () => void, context?: any): this;
        removeListener(event: "context", fn?: (gl: WebGLRenderingContext) => void, context?: any): this;
        removeAllListeners(event?: "prerender" | "postrender" | "context"): this;
        off(event: "prerender" | "postrender", fn?: () => void, context?: any): this;
        off(event: "context", fn?: (gl: WebGLRenderingContext) => void, context?: any): this;
        addListener(event: "prerender" | "postrender", fn: () => void, context?: any): this;
        addListener(event: "context", fn: (gl: WebGLRenderingContext) => void, context?: any): this;
    }
    /**
     * A WebGL state machines
     */
    class WebGLState {
        constructor(gl: WebGLRenderingContext);

        activeState: number[];
        defaultState: number[];
        stackIndex: number;
        stack: number[];
        gl: WebGLRenderingContext;
        maxAttribs: number;
        attribState: glCore.AttribState;
        nativeVaoExtension: any;

        push(): void;
        pop(): void;
        setState(state: number[]): void;
        setBlend(value: number): void;
        setBlendMode(value: number): void;
        setDepthTest(value: number): void;
        setCullFace(value: number): void;
        setFrontFace(value: number): void;
        resetAttributes(): void;
        resetToDefault(): void;
    }
    /**
     * Helper class to create a webGL Texture
     */
    class TextureManager {
        constructor(renderer: WebGLRenderer);

        renderer: WebGLRenderer;
        gl: WebGLRenderingContext;
        protected _managedTextures: Texture[];

        bindTexture(): void;
        getTexture(): WebGLTexture;
        updateTexture(texture: BaseTexture | Texture): WebGLTexture;
        destroyTexture(texture: BaseTexture, _skipRemove?: boolean): void;
        removeAll(): void;
        destroy(): void;
    }
    /**
     * TextureGarbageCollector. This class manages the GPU and ensures that it does not get clogged
     * up with textures that are no longer being used.
     */
    class TextureGarbageCollector {
        constructor(renderer: WebGLRenderer);

        renderer: WebGLRenderer;
        count: number;
        checkCount: number;
        maxIdle: number;
        checkCountMax: number;
        mode: number;

        update(): void;
        run(): void;
        unload(displayObject: DisplayObject): void;
    }
    /**
     * Base for a common object renderer that can be used as a system renderer plugin.
     */
    abstract class ObjectRenderer extends WebGLManager {
        constructor(renderer: WebGLRenderer);
        /**
         * Starts the renderer and sets the shader
         */
        start(): void;
        stop(): void;
        /**
         * Stub method for rendering content and emptying the current batch.
         */
        flush(): void;

        render(...args: any[]): void;
    }
    /**
     * Helper class to create a quad
     */
    class Quad {
        constructor(gl: WebGLRenderingContext);

        gl: WebGLRenderingContext;
        vertices: number[];
        uvs: number[];
        interleaved: number[];
        indices: number[];
        vertexBuffer: WebGLBuffer;
        vao: glCore.VertexArrayObject;
        initVao(shader: glCore.GLShader): void;
        map(targetTextureFrame: Rectangle, destinationFrame: Rectangle): Quad;
        upload(): Quad;
        destroy(): void;
    }
    interface FilterDataStackItem {
        renderTarget: RenderTarget;
        filter: any[];
        bounds: Rectangle;
    }
    class RenderTarget {
        protected filterPoolKey: string;

        constructor(
            gl: WebGLRenderingContext,
            width: number,
            height: number,
            scaleMode: number,
            resolution: number,
            root?: boolean
        );

        gl: WebGLRenderingContext;
        frameBuffer: glCore.GLFramebuffer;
        texture: Texture;
        clearColor: number[];
        size: Rectangle;
        resolution: number;
        projectionMatrix: Matrix;
        transform: Matrix;
        frame: Rectangle;
        defaultFrame: Rectangle;
        destinationFrame: Rectangle;
        sourceFrame?: Rectangle;
        stencilBuffer: glCore.GLFramebuffer;
        stencilMaskStack: Graphics[];
        filterData: {
            index: number;
            stack: FilterDataStackItem[];
        };
        scaleMode: number;
        root: boolean;

        clear(clearColor?: number[]): void;
        attachStencilBuffer(): void;
        setFrame(destinationFrame: Rectangle, sourceFrame: Rectangle): void;
        activate(): void;
        calculateProjection(destinationFrame: Rectangle, sourceFrame: Rectangle): void;
        resize(width: number, height: number): void;
        destroy(): void;
    }

    class BlendModeManager extends WebGLManager {
        constructor(renderer: WebGLRenderer);

        currentBlendMode: number;

        setBlendMode(blendMode: number): boolean;
    }
    interface FilterManagerStackItem {
        renderTarget: RenderTarget;
        sourceFrame: Rectangle;
        destinationFrame: Rectangle;
        filters: Array<Filter<any>>;
        target: any;
        resolution: number;
    }
    class FilterManager extends WebGLManager {
        constructor(renderer: WebGLRenderer);
        protected _screenWidth: number;
        protected _screenHeight: number;
        gl: WebGLRenderingContext;
        quad: Quad;
        stack: FilterManagerStackItem[];
        stackIndex: number;
        shaderCache: any;
        filterData: any;

        onPrerender(): void;
        pushFilter(target: RenderTarget, filters: Array<Filter<any>>): void;
        popFilter(): void;
        applyFilter(
            shader: glCore.GLShader | Filter<any>,
            inputTarget: RenderTarget,
            outputTarget: RenderTarget,
            clear?: boolean
        ): void;
        syncUniforms(shader: glCore.GLShader, filter: Filter<any>): void;
        getRenderTarget(clear?: boolean, resolution?: number): RenderTarget;
        returnRenderTarget(renderTarget: RenderTarget): RenderTarget;
        calculateScreenSpaceMatrix(outputMatrix: Matrix): Matrix;
        calculateNormalizedScreenSpaceMatrix(outputMatrix: Matrix): Matrix;
        calculateSpriteMatrix(outputMatrix: Matrix, sprite: Sprite): Matrix;
        destroy(contextLost?: boolean): void;
        emptyPool(): void;
        getPotRenderTarget(
            gl: WebGLRenderingContext,
            minWidth: number,
            minHeight: number,
            resolution: number
        ): RenderTarget;
        freePotRenderTarget(renderTarget: RenderTarget): void;
    }
    class StencilMaskStack {
        stencilStack: any[];
        reverse: boolean;
        count: number;
    }
    class MaskManager extends WebGLManager {
        scissor: boolean;
        scissorData: any;
        scissorRenderTarget: RenderTarget;
        enableScissor: boolean;
        alphaMaskPool: number[];
        alphaMaskIndex: number;
        pushMask(target: RenderTarget, maskData: Sprite | Graphics): void;
        popMask(target: RenderTarget, maskData: Sprite | Graphics): void;
        pushSpriteMask(target: RenderTarget, maskData: Sprite | Graphics): void;
        popSpriteMask(): void;
        pushStencilMask(maskData: Sprite | Graphics): void;
        popStencilMask(): void;
        pushScissorMask(target: RenderTarget, maskData: Sprite | Graphics): void;
        popScissorMask(): void;
    }
    class StencilManager extends WebGLManager {
        constructor(renderer: WebGLRenderer);

        stencilMaskStack: Graphics[];

        protected _useCurrent(): void;
        protected _getBitwiseMask(): number;

        setMaskStack(stencilMasStack: Graphics[]): void;
        pushStencil(graphics: Graphics): void;
        popStencil(): void;
        destroy(): void;
    }
    class WebGLManager {
        constructor(renderer: WebGLRenderer);

        renderer: WebGLRenderer;
        onContextChange(): void;
        destroy(): void;
    }
    interface UniformData<V> {
        type: string;
        value: V;

        // name is set by pixi if uniforms were automatically extracted from shader code, but not used anywhere
        name?: string;
    }
    type UniformDataMap<U> = { [K in keyof U]: UniformData<U[K]> };
    class Filter<U extends Object> {
        constructor(vertexSrc?: string, fragmentSrc?: string, uniformData?: UniformDataMap<U>);

        protected _blendMode: number;
        vertexSrc?: string;
        fragmentSrc: string;
        blendMode: number;
        protected uniformData: UniformDataMap<U>;
        uniforms: U;
        glShaders: any;
        glShaderKey?: number;
        padding: number;
        resolution: number;
        enabled: boolean;
        autoFit: boolean;
        apply(
            filterManager: FilterManager,
            input: RenderTarget,
            output: RenderTarget,
            clear?: boolean,
            currentState?: any
        ): void;

        static defaultVertexSrc: string;
        static defaultFragmentSrc: string;
    }
    interface SpriteMaskFilterUniforms {
        mask: Texture;
        otherMatrix: Matrix;
        alpha: number;
    }
    /**
     * The SpriteMaskFilter class
     */
    class SpriteMaskFilter extends Filter<SpriteMaskFilterUniforms> {
        constructor(sprite: Sprite);

        maskSprite: Sprite;
        maskMatrix: Matrix;
        apply(filterManager: FilterManager, input: RenderTarget, output: RenderTarget, clear?: boolean): void;
    }

    // sprites

    /**
     * The Sprite object is the base for all textured objects that are rendered to the screen
     *
     * A sprite can be created directly from an image like this:
     *
     * ```js
     * let sprite = new PIXI.Sprite.fromImage("assets/image.png");
     * ```
     *
     * The more efficient way to create sprites is using a {@link PIXI.Spritesheet}:
     *
     * ```js
     * PIXI.loader.add("assets/spritesheet.json").load(setup);
     *
     * function setup() {
     *   let sheet = PIXI.loader.resources["assets/spritesheet.json"].spritesheet;
     *   let sprite = new PIXI.Sprite(sheet.textures["image.png"]);
     *   ...
     * }
     * ```
     */
    class Sprite extends Container {
        constructor(texture?: Texture);

        protected _anchor: ObservablePoint;
        anchor: ObservablePoint;
        protected _texture: Texture;
        protected _transformTrimmedID: number;
        protected _textureTrimmedID: number;
        protected _width: number;
        protected _height: number;
        tint: number;
        protected _tint: number;
        protected _tintRGB: number;
        blendMode: number;
        pluginName: string;
        protected cachedTint: number;
        texture: Texture;
        protected textureDirty: boolean;
        protected _textureID: number;
        protected _transformID: number;
        protected vertexTrimmedData: Float32Array;
        vertexData: Float32Array;
        width: number;
        height: number;

        protected _onTextureUpdate(): void;
        /**
         * calculates worldTransform * vertices, store it in vertexData
         */
        calculateVertices(): void;
        protected _calculateBounds(): void;
        /**
         * calculates worldTransform * vertices for a non texture with a trim. store it in vertexTrimmedData
         * This is used to ensure that the true width and height of a trimmed texture is respected
         */
        protected calculateTrimmedVertices(): void;
        protected onAnchorUpdate(): void;
        protected _renderWebGL(renderer: WebGLRenderer): void;
        protected _renderCanvas(renderer: CanvasRenderer): void;
        /**
         * Gets the local bounds of the sprite object.
         *
         * @param rect - The output rectangle.
         * @return The bounds.
         */
        getLocalBounds(): Rectangle;
        /**
         * Tests if a point is inside this sprite
         *
         * @param point - the point to test
         * @return the result of the test
         */
        containsPoint(point: Point): boolean;
        /**
         * Destroys this sprite and optionally its texture and children
         *
         * @param [options] - Options parameter. A boolean will act as if all options have been set to that value
         */
        destroy(options?: DestroyOptions | boolean): void;

        static from(
            source: number | string | BaseTexture | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement
        ): Sprite;
        static fromFrame(frameId: string): Sprite;
        static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: number): Sprite;
    }
    class BatchBuffer {
        vertices: ArrayBuffer;
        float32View: number[];
        uint32View: number[];

        destroy(): void;
    }
    class SpriteRenderer extends ObjectRenderer {
        constructor(renderer: PIXI.WebGLRenderer);

        vertSize: number;
        vertByteSize: number;
        size: number;
        buffers: BatchBuffer[];
        indices: number[];
        shaders: Shader[];
        currentIndex: number;
        tick: number;
        groups: any[];
        sprites: Sprite[];
        vertexBuffers: number[];
        vaos: glCore.VertexArrayObject[];
        vaoMax: number;
        vertexCount: number;

        protected onContextChanged: () => void;
        protected onPrerender: () => void;
        render(sprite: Sprite): void;
        flush(): void;
        start(): void;
        stop(): void;
        destroy(): void;
    }
    class CanvasSpriteRenderer extends ObjectRenderer {
        constructor(renderer: WebGLRenderer);

        render(sprite: Sprite): void;
        destroy(): void;
    }
    namespace CanvasTinter {
        function getTintedTexture(sprite: Sprite, color: number): HTMLCanvasElement;
        function tintWithMultiply(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
        function tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
        function tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
        function roundColor(color: number): number;

        let cacheStepsPerColorChannel: number;
        let convertTintToImage: boolean;
        let canUseMultiply: boolean;
        let tintMethod: number;
    }

    // text
    interface TextStyleOptions {
        align?: string;
        breakWords?: boolean;
        dropShadow?: boolean;
        dropShadowAlpha?: number;
        dropShadowAngle?: number;
        dropShadowBlur?: number;
        dropShadowColor?: string | number;
        dropShadowDistance?: number;
        fill?: string | string[] | number | number[] | CanvasGradient | CanvasPattern;
        fillGradientType?: number;
        fillGradientStops?: number[];
        fontFamily?: string | string[];
        fontSize?: number | string;
        fontStyle?: string;
        fontVariant?: string;
        fontWeight?: string;
        letterSpacing?: number;
        lineHeight?: number;
        lineJoin?: string;
        miterLimit?: number;
        padding?: number;
        stroke?: string | number;
        strokeThickness?: number;
        textBaseline?: string;
        trim?: boolean;
        whiteSpace?: string;
        wordWrap?: boolean;
        wordWrapWidth?: number;
        leading?: number;
    }

    class TextStyle implements TextStyleOptions {
        constructor(style: TextStyleOptions);

        styleID: number;

        clone(): TextStyle;
        reset(): void;

        protected _align: string;
        align: string;
        protected _breakWords: boolean;
        breakWords: boolean;
        protected _dropShadow: boolean;
        dropShadow: boolean;
        protected _dropShadowAlpha: number;
        dropShadowAlpha: number;
        protected _dropShadowAngle: number;
        dropShadowAngle: number;
        protected _dropShadowBlur: number;
        dropShadowBlur: number;
        protected _dropShadowColor: string | number;
        dropShadowColor: string | number;
        protected _dropShadowDistance: number;
        dropShadowDistance: number;
        protected _fill: string | string[] | number | number[] | CanvasGradient | CanvasPattern;
        fill: string | string[] | number | number[] | CanvasGradient | CanvasPattern;
        protected _fillGradientType: number;
        fillGradientType: number;
        protected _fillGradientStops: number[];
        fillGradientStops: number[];
        protected _fontFamily: string | string[];
        fontFamily: string | string[];
        protected _fontSize: number | string;
        fontSize: number | string;
        protected _fontStyle: string;
        fontStyle: string;
        protected _fontVariant: string;
        fontVariant: string;
        protected _fontWeight: string;
        fontWeight: string;
        protected _leading: number;
        leading: number;
        protected _letterSpacing: number;
        letterSpacing: number;
        protected _lineHeight: number;
        lineHeight: number;
        protected _lineJoin: string;
        lineJoin: string;
        protected _miterLimit: number;
        miterLimit: number;
        protected _padding: number;
        padding: number;
        protected _stroke: string | number;
        stroke: string | number;
        protected _strokeThickness: number;
        strokeThickness: number;
        protected _textBaseline: string;
        textBaseline: string;
        protected _trim: boolean;
        trim: boolean;
        protected _whiteSpace: string;
        whiteSpace: string;
        protected _wordWrap: boolean;
        wordWrap: boolean;
        protected _wordWrapWidth: number;
        wordWrapWidth: number;
        toFontString(): string;
    }
    class TextMetrics {
        static METRICS_STRING: string;
        static BASELINE_SYMBOL: string;
        static BASELINE_MULTIPLIER: number;

        static _canvas: HTMLCanvasElement;
        static _context: CanvasRenderingContext2D;
        static _fonts: FontMetrics;
        static _newLines: number[];
        static _breakingSpaces: number[];

        text: string;
        style: TextStyle;
        width: number;
        height: number;
        lines: number[];
        lineWidths: number[];
        lineHeight: number;
        maxLineWidth: number;
        fontProperties: any;

        constructor(
            text: string,
            style: TextStyle,
            width: number,
            height: number,
            lines: number[],
            lineWidths: number[],
            lineHeight: number,
            maxLineWidth: number,
            fontProperties: any
        );

        static measureText(text: string, style: TextStyle, wordWrap?: boolean, canvas?: HTMLCanvasElement): TextMetrics;
        static wordWrap(text: string, style: TextStyle, canvas?: HTMLCanvasElement): string;
        static wordWrap(text: string, style: TextStyle, canvas?: HTMLCanvasElement): string;
        static addLine(line: string, newLine?: boolean): string;
        static getFromCache(key: string, letterSpacing: number, cache: any, context: CanvasRenderingContext2D): number;
        static collapseSpaces(whiteSpace?: string): boolean;
        static collapseNewlines(whiteSpace?: string): boolean;
        static trimRight(text?: string): string;
        static isNewline(char?: string): boolean;
        static isBreakingSpace(char?: string): boolean;
        static tokenize(text?: string): string[];
        static canBreakWords(token?: string, breakWords?: boolean): boolean;
        static canBreakChars(
            char: string,
            nextChar: string,
            token: string,
            index: number,
            breakWords?: boolean
        ): boolean;
        static measureFont(font: string): FontMetrics;
        static clearMetrics(font: string): void;
    }
    interface FontMetrics {
        ascent: number;
        descent: number;
        fontSize: number;
    }
    class Text extends Sprite {
        constructor(text?: string, style?: TextStyleOptions, canvas?: HTMLCanvasElement);

        canvas: HTMLCanvasElement;
        context: CanvasRenderingContext2D;
        resolution: number;
        protected _text: string;
        protected _style: TextStyle;
        protected _styleListener: (...args: any[]) => any;
        protected _font: string;
        protected localStyleID: number;

        width: number;
        height: number;
        style: TextStyle;
        text: string;

        protected updateText(respectDirty?: boolean): void;
        protected drawLetterSpacing(text: string, x: number, y: number, isStroke?: boolean): void;
        protected updateTexture(): void;
        renderWebGL(renderer: WebGLRenderer): void;
        protected _renderCanvas(renderer: CanvasRenderer): void;
        getLocalBounds(rect?: Rectangle): Rectangle;
        protected _calculateBounds(): void;
        protected _onStyleChange: () => void;
        protected _generateFillStyle(style: TextStyle, lines: string[]): string | number | CanvasGradient;
        destroy(options?: DestroyOptions | boolean): void;
        dirty: boolean;
    }
    // textures
    class BaseRenderTexture extends BaseTexture {
        constructor(width?: number, height?: number, scaleMode?: number, resolution?: number);

        height: number;
        width: number;
        realHeight: number;
        realWidth: number;
        resolution: number;
        scaleMode: number;
        hasLoaded: boolean;
        protected _glRenderTargets: { [n: number]: WebGLTexture };
        protected _canvasRenderTarget: { [n: number]: WebGLTexture };
        valid: boolean;

        resize(width: number, height: number): void;
        destroy(): void;

        on(event: "update", fn: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this;
        once(event: "update", fn: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this;
        removeListener(event: "update", fn?: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this;
        removeAllListeners(event?: "update"): this;
        off(event: "update", fn?: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this;
        addListener(event: "update", fn: (baseRenderTexture: BaseRenderTexture) => void, context?: any): this;
    }
    class BaseTexture extends utils.EventEmitter {
        static from(
            source: string | HTMLImageElement | HTMLCanvasElement,
            scaleMode?: number,
            sourceScale?: number
        ): BaseTexture;

        constructor(
            source?: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement,
            scaleMode?: number,
            resolution?: number
        );

        protected uuid?: number;
        protected touched: number;
        resolution: number;
        width: number;
        height: number;
        realWidth: number;
        realHeight: number;
        scaleMode: number;
        hasLoaded: boolean;
        isLoading: boolean;
        wrapMode: number;
        source: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | null;
        origSource: HTMLImageElement | null;
        imageType: string | null;
        sourceScale: number;
        premultipliedAlpha: boolean;
        imageUrl: string | null;
        protected isPowerOfTwo: boolean;
        mipmap: boolean;
        wrap?: boolean;
        protected _glTextures: any;
        protected _enabled: number;
        protected _id?: number;
        protected _virtualBoundId: number;
        protected readonly _destroyed: boolean;
        textureCacheIds: string[];

        update(): void;
        protected _updateDimensions(): void;
        protected _updateImageType(): void;
        protected _loadSvgSource(): void;
        protected _loadSvgSourceUsingDataUri(dataUri: string): void;
        protected _loadSvgSourceUsingXhr(): void;
        protected _loadSvgSourceUsingString(svgString: string): void;
        protected loadSource(source: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement): void;
        protected _sourceLoaded(): void;
        destroy(): void;
        dispose(): void;
        updateSourceImage(newSrc: string): void;

        static fromImage(
            imageUrl: string,
            crossorigin?: boolean,
            scaleMode?: number,
            sourceScale?: number
        ): BaseTexture;
        static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: number, origin?: string): BaseTexture;
        static addToCache(baseTexture: BaseTexture, id: string): void;
        static removeFromCache(baseTexture: string | BaseTexture): BaseTexture;

        on(
            event: "update" | "loaded" | "error" | "dispose",
            fn: (baseTexture: BaseTexture) => void,
            context?: any
        ): this;
        once(
            event: "update" | "loaded" | "error" | "dispose",
            fn: (baseTexture: BaseTexture) => void,
            context?: any
        ): this;
        removeListener(
            event: "update" | "loaded" | "error" | "dispose",
            fn?: (baseTexture: BaseTexture) => void,
            context?: any
        ): this;
        removeAllListeners(event?: "update" | "loaded" | "error" | "dispose"): this;
        off(
            event: "update" | "loaded" | "error" | "dispose",
            fn?: (baseTexture: BaseTexture) => void,
            context?: any
        ): this;
        addListener(
            event: "update" | "loaded" | "error" | "dispose",
            fn: (baseTexture: BaseTexture) => void,
            context?: any
        ): this;
    }
    class RenderTexture extends Texture {
        constructor(baseRenderTexture: BaseRenderTexture, frame?: Rectangle);

        protected legacyRenderer: any;
        valid: boolean;

        resize(width: number, height: number, doNotResizeBaseTexture?: boolean): void;

        static create(width?: number, height?: number, scaleMode?: number, resolution?: number): RenderTexture;
    }
    class Texture extends utils.EventEmitter {
        constructor(
            baseTexture: BaseTexture,
            frame?: Rectangle,
            orig?: Rectangle,
            trim?: Rectangle,
            rotate?: number,
            anchor?: Point
        );

        noFrame: boolean;
        baseTexture: BaseTexture;
        protected _frame: Rectangle;
        trim?: Rectangle;
        valid: boolean;
        requiresUpdate: boolean;
        protected _uvs: TextureUvs;
        orig: Rectangle;
        defaultAnchor: Point;
        protected _updateID: number;
        transform: TextureMatrix;
        textureCacheIds: string[];

        update(): void;
        protected onBaseTextureLoaded(baseTexture: BaseTexture): void;
        protected onBaseTextureUpdated(baseTexture: BaseTexture): void;
        destroy(destroyBase?: boolean): void;
        clone(): Texture;
        _updateUvs(): void;

        static fromImage(imageUrl: string, crossOrigin?: boolean, scaleMode?: number, sourceScale?: number): Texture;
        static fromFrame(frameId: string): Texture;
        static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: number, origin?: string): Texture;
        static fromVideo(
            video: HTMLVideoElement | string,
            scaleMode?: number,
            crossorigin?: boolean,
            autoPlay?: boolean
        ): Texture;
        static fromVideoUrl(videoUrl: string, scaleMode?: number, crossorigin?: boolean, autoPlay?: boolean): Texture;
        static from(
            source: number | string | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | BaseTexture
        ): Texture;
        static fromLoader(source: HTMLImageElement | HTMLCanvasElement, imageUrl: string, name?: string): Texture;
        static addToCache(texture: Texture, id: string): void;
        static removeFromCache(texture: string | Texture): Texture;

        // depreciation
        static addTextureToCache(texture: Texture, id: string): void;
        static removeTextureFromCache(id: string): Texture;

        frame: Rectangle;
        protected _rotate: boolean | 0;
        rotate: number;
        width: number;
        height: number;

        static EMPTY: Texture;
        static WHITE: Texture;

        on(event: "update", fn: (texture: Texture) => void, context?: any): this;
        once(event: "update", fn: (texture: Texture) => void, context?: any): this;
        removeListener(event: "update", fn?: (texture: Texture) => void, context?: any): this;
        removeAllListeners(event?: "update"): this;
        off(event: "update", fn?: (texture: Texture) => void, context?: any): this;
        addListener(event: "update", fn: (texture: Texture) => void, context?: any): this;
    }
    class TextureMatrix {
        constructor(texture: Texture, clampMargin?: number);

        protected _texture: Texture;
        mapCoord: Matrix;
        uClampFrame: Float32Array;
        uClampOffset: Float32Array;
        protected _lastTextureID: number;

        clampOffset: number;
        clampMargin: number;

        texture: Texture;

        update(forceUpdate?: boolean): boolean;
        multiplyUvs(uvs: Float32Array, out?: Float32Array): Float32Array;
    }
    class TextureUvs {
        x0: number;
        y0: number;
        x1: number;
        y1: number;
        x2: number;
        y2: number;
        x3: number;
        y3: number;

        uvsUint32: Uint32Array;

        protected set(frame: Rectangle, baseFrame: Rectangle, rotate: number): void;
    }

    class Spritesheet {
        static BATCH_SIZE: number;

        constructor(baseTexture: BaseTexture, data: any, resolutionFilename?: string);

        baseTexture: BaseTexture;
        animations: { [key: string]: Texture[] };
        textures: { [key: string]: Texture };
        data: any;
        resolution: number;
        protected _frames: any;
        protected _frameKeys: string;
        protected _batchIndex: number;
        protected _callback: (spriteSheet: this, textures: { [key: string]: Texture }) => void;
        protected _updateResolution(resolutionFilename: string): number;
        parse(callback: (spriteSheet: this, textures: { [key: string]: Texture }) => void): void;
        protected _processFrames(initialFrameIndex: number): void;
        protected _parseComplete(): void;
        protected _processAnimations(): void;
        protected _nextBatch(): void;
        destroy(destroyBase?: boolean): void;
    }

    class VideoBaseTexture extends BaseTexture {
        constructor(source: HTMLVideoElement, scaleMode?: number, autoPlay?: boolean);

        autoUpdate: boolean;
        autoPlay: boolean;
        protected _isAutoUpdating: boolean;

        update(): void;
        protected _onCanPlay(): void;
        protected _onPlayStart(): void;
        protected _onPlayStop(): void;
        destroy(): void;
        protected _isSourcePlaying(): boolean;
        protected _isSourceReady(): boolean;

        static fromVideo(video: HTMLVideoElement, scaleMode?: number, autoPlay?: boolean): VideoBaseTexture;
        static fromUrl(
            videoSrc: string | any | string[] | any[],
            crossorigin?: boolean,
            autoPlay?: boolean
        ): VideoBaseTexture;
        static fromUrls(videoSrc: string | any | string[] | any[]): VideoBaseTexture;

        source: HTMLVideoElement;
        protected loadSource(source: HTMLVideoElement): void;
    }

    // ticker

    namespace ticker {
        const shared: Ticker;

        class TickerListener {
            constructor(fn: (deltaTime: number) => void, context?: any, priority?: number, once?: boolean);
            fn: (deltaTime: number) => void;
            context: any;
            priority: number;
            once: boolean;
            next: TickerListener;
            previous: TickerListener;
            protected _destroyed: boolean;
            match(fn: (deltaTime: number) => void, context?: any): boolean;
            emit(deltaTime: number): TickerListener;
            connect(previous: TickerListener): void;
            destroy(hard?: boolean): void;
        }
        class Ticker {
            protected _tick: (time: number) => void;
            protected _head: TickerListener;
            protected _requestId: number | null;
            protected _maxElapsedMS: number;

            autoStart: boolean;
            deltaTime: number;
            elapsedMS: number;
            lastTime: number;
            speed: number;
            started: boolean;

            protected _requestIfNeeded(): void;
            protected _cancelIfNeeded(): void;
            protected _startIfPossible(): void;

            add(fn: (deltaTime: number) => void, context?: any, priority?: number): Ticker;
            addOnce(fn: (deltaTime: number) => void, context?: any, priority?: number): Ticker;
            remove(fn: (...args: any[]) => any, context?: any, priority?: number): Ticker;
            protected _addListener(listener: TickerListener): Ticker;
            readonly FPS: number;
            minFPS: number;

            start(): void;
            stop(): void;
            destroy(): void;
            update(currentTime?: number): void;
        }
    }

    // shader

    /**
     * Wrapper class, webGL Shader for Pixi.
     * Adds precision string if vertexSrc or fragmentSrc have no mention of it.
     */
    class Shader extends glCore.GLShader {
        constructor(
            gl: WebGLRenderingContext,
            vertexSrc: string | string[],
            fragmentSrc: string | string[],
            attributeLocations?: { [key: string]: number },
            precision?: string
        );
    }

    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////EXTRACT///////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    namespace extract {
        class CanvasExtract {
            protected renderer: CanvasRenderer;

            constructor(renderer: CanvasRenderer);

            image(target?: DisplayObject | RenderTexture): HTMLImageElement;
            base64(target?: DisplayObject | RenderTexture): string;
            canvas(target?: DisplayObject | RenderTexture): HTMLCanvasElement;
            pixels(renderTexture?: DisplayObject | RenderTexture): Uint8ClampedArray;

            destroy(): void;
        }
        class WebGLExtract {
            protected renderer: WebGLRenderer;

            constructor(renderer: WebGLRenderer);

            image(target?: DisplayObject | RenderTexture): HTMLImageElement;
            base64(target?: DisplayObject | RenderTexture): string;
            canvas(target?: DisplayObject | RenderTexture): HTMLCanvasElement;
            pixels(renderTexture?: DisplayObject | RenderTexture): Uint8Array;

            destroy(): void;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////EXTRAS////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    namespace extras {
        interface BitmapTextStyle {
            font?:
                | string
                | {
                      name?: string;
                      size?: number;
                  };
            align?: string;
            tint?: number;
        }
        class BitmapText extends Container {
            static registerFont(xml: XMLDocument, textures: Texture | Texture[] | { [key: string]: Texture }): any;

            constructor(text: string, style?: BitmapTextStyle);

            letterSpacing: number;
            protected _letterSpacing: number;
            protected _textWidth: number;
            protected _textHeight: number;
            textWidth: number;
            textHeight: number;
            protected _glyphs: Sprite[];
            protected _font:
                | string
                | {
                      name?: string;
                      size?: number;
                  };
            font:
                | string
                | {
                      name?: string;
                      size?: number;
                  };
            protected _text: string;
            protected _maxWidth: number;
            maxWidth: number;
            protected _maxLineHeight: number;
            maxLineHeight: number;
            protected _anchor: ObservablePoint;
            dirty: boolean;
            tint: number;
            align: string;
            text: string;
            anchor: PIXI.Point | number;

            protected updateText(): void;
            updateTransform(): void;
            getLocalBounds(): Rectangle;
            protected validate(): void;

            static fonts: any;
        }
        interface AnimatedSpriteTextureTimeObject {
            texture: Texture;
            time?: number;
        }
        class AnimatedSprite extends Sprite {
            constructor(textures: Texture[] | AnimatedSpriteTextureTimeObject[], autoUpdate?: boolean);

            protected _autoUpdate: boolean;
            protected _textures: Texture[];
            protected _durations: number[];
            textures: Texture[] | AnimatedSpriteTextureTimeObject[];
            animationSpeed: number;
            loop: boolean;
            updateAnchor: boolean;
            onComplete: () => void;
            onFrameChange: (currentFrame: number) => void;
            onLoop: () => void;
            protected _currentTime: number;
            playing: boolean;
            totalFrames: number;
            currentFrame: number;
            stop(): void;
            play(): void;
            gotoAndStop(frameNumber: number): void;
            gotoAndPlay(frameNumber: number): void;
            protected update(deltaTime: number): void;
            destroy(options?: DestroyOptions | boolean): void;

            static fromFrames(frame: string[]): AnimatedSprite;
            static fromImages(images: string[]): AnimatedSprite;
        }
        class TextureMatrix {
            constructor(texture: Texture, clampMargin?: number);

            protected _texture: Texture;
            mapCoord: Matrix;
            uClampFrame: Float32Array;
            uClampOffset: Float32Array;
            protected _lastTextureID: number;

            clampOffset: number;
            clampMargin: number;

            texture: Texture;

            update(forceUpdate?: boolean): boolean;
            multiplyUvs(uvs: Float32Array, out?: Float32Array): Float32Array;
        }
        class TilingSprite extends Sprite {
            constructor(texture: Texture, width?: number, height?: number);

            tileTransform: TransformStatic;
            protected _width: number;
            protected _height: number;
            protected _canvasPattern: CanvasPattern;
            uvTransform: TextureMatrix;
            uvRespectAnchor: boolean;

            clampMargin: number;
            tileScale: Point | ObservablePoint;
            tilePosition: Point | ObservablePoint;

            multiplyUvs(uvs: Float32Array, out: Float32Array): Float32Array;
            protected _onTextureUpdate(): void;
            protected _renderWebGL(renderer: WebGLRenderer): void;
            protected _renderCanvas(renderer: CanvasRenderer): void;
            protected _calculateBounds(): void;
            getLocalBounds(rect?: Rectangle): Rectangle;
            containsPoint(point: Point): boolean;
            destroy(options?: DestroyOptions | boolean): void;

            static from(
                source: number | string | BaseTexture | HTMLCanvasElement | HTMLVideoElement,
                width?: number,
                height?: number
            ): TilingSprite;
            static fromFrame(frameId: string, width?: number, height?: number): TilingSprite;
            // if you remove the next line, the class will break. https://github.com/pixijs/pixi-typescript/issues/96
            static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: number): Sprite;
            static fromImage(
                imageId: string,
                width?: number,
                height?: number,
                crossorigin?: boolean,
                scaleMode?: number
            ): TilingSprite;

            width: number;
            height: number;
        }
        class TilingSpriteRenderer extends ObjectRenderer {
            constructor(renderer: WebGLRenderer);

            render(ts: TilingSprite): void;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////FILTERS///////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    namespace filters {
        class FXAAFilter extends Filter<{}> {}
        class BlurFilter extends Filter<{}> {
            constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);

            blurXFilter: BlurXFilter;
            blurYFilter: BlurYFilter;
            resolution: number;
            padding: number;
            passes: number;
            blur: number;
            blurX: number;
            blurY: number;
            quality: number;
            blendMode: number;
        }
        interface BlurXFilterUniforms {
            strength: number;
        }
        class BlurXFilter extends Filter<BlurXFilterUniforms> {
            constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);

            protected _quality: number;

            quality: number;
            passes: number;
            resolution: number;
            strength: number;
            firstRun: boolean;
            blur: number;
        }
        interface BlurYFilterUniforms {
            strength: number;
        }
        class BlurYFilter extends Filter<BlurYFilterUniforms> {
            constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);

            protected _quality: number;

            quality: number;
            passes: number;
            resolution: number;
            strength: number;
            firstRun: boolean;
            blur: number;
        }
        interface ColorMatrixFilterUniforms {
            m: Matrix;
            uAlpha: number;
        }
        class ColorMatrixFilter extends Filter<ColorMatrixFilterUniforms> {
            constructor();

            protected _loadMatrix(matrix: number[], multiply?: boolean): void;
            protected _multiply(out: number[], a: number[], b: number[]): void;
            protected _colorMatrix(matrix: number[]): void;

            matrix: number[];
            alpha: number;

            brightness(b: number, multiply?: boolean): void;
            greyscale(scale: number, multiply?: boolean): void;
            blackAndWhite(multiply?: boolean): void;
            hue(rotation: number, multiply?: boolean): void;
            contrast(amount: number, multiply?: boolean): void;
            saturate(amount: number, multiply?: boolean): void;
            desaturate(multiply?: boolean): void;
            negative(multiply?: boolean): void;
            sepia(multiply?: boolean): void;
            technicolor(multiply?: boolean): void;
            polaroid(multiply?: boolean): void;
            toBGR(multiply?: boolean): void;
            kodachrome(multiply?: boolean): void;
            browni(multiply?: boolean): void;
            vintage(multiply?: boolean): void;
            colorTone(
                desaturation: number,
                toned: number,
                lightColor: string,
                darkColor: string,
                multiply?: boolean
            ): void;
            night(intensity: number, multiply?: boolean): void;
            predator(amount: number, multiply?: boolean): void;
            lsd(multiply?: boolean): void;
            reset(): void;
        }
        interface DisplacementFilterUniforms {
            mapSampler: Texture;
            filterMatrix: Matrix;
            scale: Point;
        }
        class DisplacementFilter extends Filter<DisplacementFilterUniforms> {
            constructor(sprite: Sprite, scale?: number);

            scale: Point;
            map: Texture;
        }
        class AlphaFilter extends Filter<{}> {
            constructor(alpha?: number);

            alpha: number;
            glShaderKey: number;
        }
        interface NoiseFilterUniforms {
            uNoise: number;
            uSeed: number;
        }
        // pixi-filters.d.ts todo
        // https://github.com/pixijs/pixi-filters/
        class NoiseFilter extends Filter<NoiseFilterUniforms> {
            constructor(noise?: number, seed?: number);
            noise: number;
            seed: number;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////INTERACTION///////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    namespace interaction {
        interface InteractiveTarget {
            /**
             * Enable interaction events for the DisplayObject. Touch, pointer and mouse
             * events will not be emitted unless `interactive` is set to `true`.
             *
             * @example
             * const sprite = new PIXI.Sprite(texture);
             * sprite.interactive = true;
             * sprite.on("tap", (event) => {
             *    //handle event
             * });
             */
            interactive: boolean;
            /**
             * Determines if the children to the displayObject can be clicked/touched
             * Setting this to false allows PixiJS to bypass a recursive `hitTest` function
             */
            interactiveChildren: boolean;
            /**
             * Interaction shape. Children will be hit first, then this shape will be checked.
             * Setting this will cause this shape to be checked in hit tests rather than the displayObject"s bounds.
             * @example
             * const sprite = new PIXI.Sprite(texture);
             * sprite.interactive = true;
             * sprite.hitArea = new PIXI.Rectangle(0, 0, 100, 100);
             */
            hitArea: PIXI.Rectangle | PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.RoundedRectangle | PIXI.HitArea;
            /**
             * If enabled, the mouse cursor use the pointer behavior when hovered over the displayObject if it is interactive
             * Setting this changes the "cursor" property to `"pointer"`.
             *
             * @example
             * const sprite = new PIXI.Sprite(texture);
             * sprite.interactive = true;
             * sprite.buttonMode = true;
             */
            buttonMode: boolean;
            /**
             * This defines what cursor mode is used when the mouse cursor
             * is hovered over the displayObject.
             * @example
             * const sprite = new PIXI.Sprite(texture);
             * sprite.interactive = true;
             * sprite.cursor = "wait";
             * @see https://developer.mozilla.org/en/docs/Web/CSS/cursor
             */
            cursor: string;
            trackedPointers: { [key: number]: InteractionTrackingData };

            /** @deprecated */
            defaultCursor: string;
        }
        interface InteractionTrackingData {
            readonly pointerId: number;
            flags: number;
            none: number;
            over: boolean;
            rightDown: boolean;
            leftDown: boolean;
        }
        interface InteractionEvent {
            stopped: boolean;
            target: DisplayObject;
            currentTarget: DisplayObject;
            type: string;
            data: InteractionData;
            stopPropagation(): void;
            reset(): void;
        }
        class InteractionData {
            global: Point;
            target: DisplayObject;
            originalEvent: MouseEvent | TouchEvent | PointerEvent;
            identifier: number;
            isPrimary: boolean;
            button: number;
            buttons: number;
            width: number;
            height: number;
            tiltX: number;
            tiltY: number;
            pointerType: string;
            pressure: number;
            rotationAngle: number;
            twist: number;
            tangentialPressure: number;
            readonly pointerID: number;
            copyEvent(event: Touch | MouseEvent | PointerEvent): void;
            reset(): void;
            getLocalPosition(displayObject: DisplayObject, point?: Point, globalPos?: Point): Point;
        }
        type InteractionPointerEvents =
            | "pointerdown"
            | "pointercancel"
            | "pointerup"
            | "pointertap"
            | "pointerupoutside"
            | "pointermove"
            | "pointerover"
            | "pointerout";
        type InteractionTouchEvents =
            | "touchstart"
            | "touchcancel"
            | "touchend"
            | "touchendoutside"
            | "touchmove"
            | "tap";
        type InteractionMouseEvents =
            | "rightdown"
            | "mousedown"
            | "rightup"
            | "mouseup"
            | "rightclick"
            | "click"
            | "rightupoutside"
            | "mouseupoutside"
            | "mousemove"
            | "mouseover"
            | "mouseout";
        type InteractionPixiEvents = "added" | "removed";
        type InteractionEventTypes =
            | InteractionPointerEvents
            | InteractionTouchEvents
            | InteractionMouseEvents
            | InteractionPixiEvents;
        interface InteractionManagerOptions {
            autoPreventDefault?: boolean;
            interactionFrequency?: number;
        }
        class InteractionManager extends utils.EventEmitter {
            constructor(renderer: CanvasRenderer | WebGLRenderer | SystemRenderer, options?: InteractionManagerOptions);

            renderer: SystemRenderer;
            autoPreventDefault: boolean;
            interactionFrequency: number;
            mouse: InteractionData;
            activeInteractionData: { [key: number]: InteractionData };
            interactionDataPool: InteractionData[];
            eventData: InteractionEvent;
            protected interactionDOMElement: HTMLElement;
            moveWhenInside: boolean;
            eventsAdded: boolean;
            protected mouseOverRenderer: boolean;
            readonly supportsTouchEvents: boolean;
            readonly supportsPointerEvents: boolean;
            protected onPointerUp: (event: PointerEvent) => void;
            protected processPointerUp: (
                interactionEvent: InteractionEvent,
                displayObject: Container | PIXI.Sprite | PIXI.extras.TilingSprite,
                hit: boolean
            ) => void;
            protected onPointerCancel: (event: PointerEvent) => void;
            protected processPointerCancel: (
                interactionEvent: InteractionEvent,
                displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite
            ) => void;
            protected onPointerDown: (event: PointerEvent) => void;
            protected processPointerDown: (
                interactionEvent: InteractionEvent,
                displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite,
                hit: boolean
            ) => void;
            protected onPointerMove: (event: PointerEvent) => void;
            protected processPointerMove: (
                interactionEvent: InteractionEvent,
                displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite,
                hit: boolean
            ) => void;
            protected onPointerOut: (event: PointerEvent) => void;
            protected processPointerOverOut: (
                interactionEvent: InteractionEvent,
                displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite,
                hit: boolean
            ) => void;
            protected onPointerOver: (event: PointerEvent) => void;
            cursorStyles: {
                default: string;
                pointer: string;
            };
            currentCursorMode: string;
            cursor: string;
            protected _tempPoint: Point;
            resolution: number;
            hitTest(globalPoint: Point, root?: Container): DisplayObject;
            setTargetElement(element: HTMLCanvasElement, resolution?: number): void;
            protected addEvents(): void;
            protected removeEvents(): void;
            update(deltaTime?: number): void;
            setCursorMode(mode: string): void;
            protected dispatchEvent(
                displayObject: Container | Sprite | extras.TilingSprite,
                eventString: string,
                eventData: any
            ): void;
            mapPositionToPoint(point: Point, x: number, y: number): void;
            protected processInteractive(
                interactionEvent: InteractionEvent,
                displayObject: PIXI.Container | PIXI.Sprite | PIXI.extras.TilingSprite,
                func?: (...args: any[]) => any,
                hitTest?: boolean,
                interactive?: boolean
            ): boolean;
            protected onPointerComplete(
                originalEvent: PointerEvent,
                cancelled: boolean,
                func: (...args: any[]) => any
            ): void;
            protected getInteractionDataForPointerId(pointerId: number): InteractionData;
            protected releaseInteractionDataForPointerId(event: PointerEvent): void;
            protected configureInteractionEventForDOMEvent(
                interactionEvent: InteractionEvent,
                pointerEvent: PointerEvent,
                interactionData: InteractionData
            ): InteractionEvent;
            protected normalizeToPointerData(event: TouchEvent | MouseEvent | PointerEvent): PointerEvent[];
            destroy(): void;

            // Deprecated
            defaultCursorStyle: string;
            currentCursorStyle: string;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////LOADER/////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    // pixi loader extends
    // https://github.com/englercj/resource-loader/
    // 2.2.3

    class MiniSignalBinding {
        detach(): boolean;
    }
    class MiniSignal<CbType extends (...args: any[]) => any> {
        constructor();
        handlers(exists: true): boolean;
        handlers(exists?: false): MiniSignalBinding[];
        has(node: MiniSignalBinding): boolean;
        add(fn: (...args: any[]) => any, thisArg?: any): any;
        add(fn: CbType, thisArg?: any): MiniSignalBinding;
        once(fn: (...args: any[]) => any, thisArg?: any): any;
        once(fn: CbType, thisArg?: any): MiniSignalBinding;
        detach(node: MiniSignalBinding): MiniSignal<CbType>;
        detachAll(): MiniSignal<CbType>;
        dispatch: CbType;
    }
    namespace loaders {
        /**
         * Options for a call to `.add()`.
         * @property [name] - The name of the resource to load, if not passed the url is used.
         * @property [key] - Alias for `name`.
         * @property [url] - The url for this resource, relative to the baseUrl of this loader.
         * @property [crossOrigin] - Is this request cross-origin? Default is to
         *      determine automatically.
         * @property [timeout=0] - A timeout in milliseconds for the load. If the load takes
         *      longer than this time it is cancelled and the load is considered a failure. If this value is
         *      set to `0` then there is no explicit timeout.
         * @property [loadType=Resource.LOAD_TYPE.XHR] - How should this resource
         *      be loaded?
         * @property [xhrType=Resource.XHR_RESPONSE_TYPE.DEFAULT] - How
         *      should the data being loaded be interpreted when using XHR?
         * @property [onComplete] - Callback to add an an onComplete signal istener.
         * @property [callback] - Alias for `onComplete`.
         * @property [metadata] - Extra configuration for middleware and the Resource object.
         */
        interface LoaderOptions {
            crossOrigin?: string | boolean;
            timeout?: number;
            loadType?: Resource.LOAD_TYPE;
            xhrType?: Resource.XHR_RESPONSE_TYPE;
            onComplete?: OnCompleteSignal;
            callback?: OnCompleteSignal;
            metadata?: IMetadata;
        }
        interface ResourceDictionary {
            [key: string]: PIXI.loaders.Resource;
        }
        function encodeBinary(input: string): string;
        type OnProgressSignal = (loader: Loader, resource: Resource) => void;
        type OnErrorSignal = (loader: Loader, resource: Resource) => void;
        type OnLoadSignal = (loader: Loader, resource: Resource) => void;
        type OnStartSignal = (loader: Loader) => void;
        type OnCompleteSignal = (loader: Loader) => void;

        // As of ResourceLoader v2 we no longer require EventEmitter
        // However, for depreciation reasons, it remains.
        class Loader extends utils.EventEmitter {
            // pixi overrides here
            static addPixiMiddleware(fn: (...args: any[]) => any): void;

            // below this line is the original non-pixi loader

            constructor(baseUrl?: string, concurrency?: number);
            static Resource: typeof Resource;
            static async: typeof Resource;
            static encodeBinary: typeof encodeBinary;
            static base64: typeof encodeBinary;
            baseUrl: string;
            progress: number;
            loading: boolean;
            defaultQueryString: string;
            resources: ResourceDictionary;

            onProgress: MiniSignal<OnProgressSignal>;
            onError: MiniSignal<OnErrorSignal>;
            onLoad: MiniSignal<OnLoadSignal>;
            onStart: MiniSignal<OnStartSignal>;
            onComplete: MiniSignal<OnCompleteSignal>;

            add(name: string, url: string, callback?: OnCompleteSignal): this;
            add(name: string, url: string, options?: LoaderOptions, callback?: OnCompleteSignal): this;
            add(url: string, callback?: OnCompleteSignal): this;
            add(url: string, options?: LoaderOptions, callback?: OnCompleteSignal): this;
            add(options: LoaderOptions, callback?: OnCompleteSignal): this;
            add(resources: Array<LoaderOptions | string>, callback?: OnCompleteSignal): this;
            add(...params: any[]): this;
            pre(fn: (...params: any[]) => any): this;
            use(fn: (...params: any[]) => any): this;
            reset(): this;
            load(cb?: (...params: any[]) => any): this;
            concurrency: number;
            static pre(fn: (...params: any[]) => any): Loader;
            static use(fn: (...params: any[]) => any): Loader;

            destroy(): void;

            // depreciation

            on(event: "complete", fn: (loader: loaders.Loader, object: any) => void, context?: any): this;
            on(
                event: "error",
                fn: (error: Error, loader: loaders.Loader, resource: Resource) => void,
                context?: any
            ): this;
            on(
                event: "load" | "progress",
                fn: (loader: loaders.Loader, resource: Resource) => void,
                context?: any
            ): this;
            on(event: "start", fn: (loader: loaders.Loader) => void, context?: any): this;

            once(event: "complete", fn: (loader: loaders.Loader, object: any) => void, context?: any): this;
            once(
                event: "error",
                fn: (error: Error, loader: loaders.Loader, resource: Resource) => void,
                context?: any
            ): this;
            once(
                event: "load" | "progress",
                fn: (loader: loaders.Loader, resource: Resource) => void,
                context?: any
            ): this;
            once(event: "start", fn: (loader: loaders.Loader) => void, context?: any): this;
            off(
                event: "complete" | "error" | "load" | "progress" | "start" | string,
                fn?: (...args: any[]) => any,
                context?: any
            ): this;
        }
        interface TextureDictionary {
            [index: string]: PIXI.Texture;
        }
        interface IMetadata {
            loadElement?: HTMLImageElement | HTMLAudioElement | HTMLVideoElement;
            skipSource?: boolean;
            mimeType?: string | string[];
        }
        class Resource {
            constructor(name: string, url: string | string[], options?: LoaderOptions);
            readonly name: string;
            readonly url: string;
            readonly extension: string;
            data: any;
            crossOrigin: string;
            timeout: number;
            loadType: Resource.LOAD_TYPE;
            xhrType: string;
            metadata: IMetadata;
            readonly error: Error;
            readonly xhr: XMLHttpRequest;
            readonly children: Resource[];
            readonly type: Resource.LOAD_TYPE;
            readonly progressChunk: number;
            onStart: MiniSignal<OnStartSignal>;
            onProgress: MiniSignal<OnProgressSignal>;
            onComplete: MiniSignal<OnCompleteSignal>;
            onAfterMiddleware: MiniSignal<OnCompleteSignal>;
            readonly isDataUrl: boolean;
            readonly isComplete: boolean;
            readonly isLoading: boolean;
            complete(): void;
            abort(message: string): void;
            load(cb?: OnCompleteSignal): void;
            texture: Texture;
            sound: any;
            spineAtlas: any;
            spineData: any;
            textures?: TextureDictionary;
            spritesheet?: Spritesheet;
        }
        namespace Resource {
            enum STATUS_FLAGS {
                NONE,
                DATA_URL,
                COMPLETE,
                LOADING
            }
            enum TYPE {
                UNKNOWN,
                JSON,
                XML,
                IMAGE,
                AUDIO,
                VIDEO,
                TEXT
            }
            enum LOAD_TYPE {
                XHR,
                IMAGE,
                AUDIO,
                VIDEO
            }
            enum XHR_RESPONSE_TYPE {
                DEFAULT,
                BUFFER,
                BLOB,
                DOCUMENT,
                JSON,
                TEXT
            }
            function setExtensionLoadType(extname: string, loadType: Resource.LOAD_TYPE): void;
            function setExtensionXhrType(extname: string, xhrType: Resource.XHR_RESPONSE_TYPE): void;
            const EMPTY_GIF: string;
        }
        const shared: Loader;
    }

    //////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////MESH///////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    namespace mesh {
        class Mesh extends Container {
            constructor(
                texture: Texture,
                vertices?: Float32Array,
                uvs?: Float32Array,
                indices?: Uint16Array,
                drawMode?: number
            );

            protected _texture: Texture;
            uvs: Float32Array;
            vertices: Float32Array;
            indices: Uint16Array;
            dirty: number;
            indexDirty: number;
            vertexDirty: number;
            autoUpdate: boolean;
            dirtyVertex: boolean;
            protected _geometryVersion: number;
            blendMode: number;
            pluginName: string;
            canvasPadding: number;
            drawMode: number;
            texture: Texture;
            tintRgb: Float32Array;
            protected _glDatas: { [n: number]: any };
            protected _uvTransform: extras.TextureMatrix;
            uploadUvTransform: boolean;
            multiplyUvs(): void;
            refresh(forceUpdate?: boolean): void;
            protected _refresh(): void;
            protected _renderWebGL(renderer: WebGLRenderer): void;
            protected _renderCanvas(renderer: CanvasRenderer): void;
            protected _onTextureUpdate(): void;
            protected _calculateBounds(): void;
            containsPoint(point: Point): boolean;
            tint: number;

            static DRAW_MODES: {
                TRIANGLE_MESH: number;
                TRIANGLES: number;
            };
        }

        class CanvasMeshRenderer {
            constructor(renderer: CanvasRenderer);

            renderer: CanvasRenderer;

            render(mesh: Mesh): void;
            protected _renderTriangleMesh(mesh: Mesh): void;
            protected _renderTriangles(mesh: Mesh): void;
            protected _renderDrawTriangle(mesh: Mesh, index0: number, index1: number, index2: number): void;
            protected renderMeshFlat(mesh: Mesh): void;

            destroy(): void;
        }

        class MeshRenderer extends ObjectRenderer {
            constructor(renderer: WebGLRenderer);

            shader: Shader;
            render(mesh: Mesh): void;
        }

        class Plane extends Mesh {
            constructor(texture: Texture, verticesX?: number, verticesY?: number);
            protected _ready: boolean;
            verticesX: number;
            verticesY: number;
            drawMode: number;

            refresh(): void;

            protected _onTexureUpdate(): void;
        }

        class NineSlicePlane extends Plane {
            constructor(
                texture: Texture,
                leftWidth?: number,
                topHeight?: number,
                rightWidth?: number,
                bottomHeight?: number
            );

            width: number;
            height: number;
            leftWidth: number;
            rightWidth: number;
            topHeight: number;
            bottomHeight: number;

            protected _leftWidth: number;
            protected _rightWidth: number;
            protected _topHeight: number;
            protected _bottomHeight: number;
            protected _height: number;
            protected _width: number;
            protected _origHeight: number;
            protected _origWidth: number;
            protected _uvh: number;
            protected _uvw: number;

            updateHorizontalVertices(): void;
            updateVerticalVertices(): void;
            protected drawSegment(
                context: CanvasRenderingContext2D | WebGLRenderingContext,
                textureSource: any,
                w: number,
                h: number,
                x1: number,
                y1: number,
                x2: number,
                y2: number
            ): void;
            protected _renderCanvas(renderer: CanvasRenderer): void;
            protected _refresh(): void;
        }

        class Rope extends Mesh {
            constructor(texture: Texture, points: Point[]);

            points: Point[];
            colors: number[];
            autoUpdate: boolean;
            protected _refresh(): void;

            refreshVertices(): void;
        }
    }
    //////////////////////////////////////////////////////////////////////////////
    /////////////////////////////PARTICLES////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////
    namespace particles {
        interface ParticleContainerProperties {
            /**
             * DEPRECIATED - Use `vertices`
             */
            scale?: boolean;
            vertices?: boolean;
            position?: boolean;
            rotation?: boolean;
            uvs?: boolean;
            tint?: boolean;
            alpha?: boolean;
        }
        class ParticleContainer extends Container {
            constructor(
                maxSize?: number,
                properties?: ParticleContainerProperties,
                batchSize?: number,
                autoResize?: boolean
            );
            protected _tint: number;
            protected tintRgb: number | any[];
            tint: number;
            protected _properties: boolean[];
            protected _maxSize: number;
            protected _batchSize: number;
            protected _glBuffers: { [n: number]: WebGLBuffer };
            protected _bufferUpdateIDs: number[];
            protected _updateID: number;
            interactiveChildren: boolean;
            blendMode: number;
            autoSize: boolean;
            roundPixels: boolean;
            baseTexture: BaseTexture;

            setProperties(properties: ParticleContainerProperties): void;
            protected onChildrenChange: (smallestChildIndex?: number) => void;

            destroy(options?: DestroyOptions | boolean): void;
        }
        class ParticleBuffer {
            constructor(gl: WebGLRenderingContext, properties: any, dynamicPropertyFlags: any[], size: number);

            gl: WebGLRenderingContext;
            size: number;
            dynamicProperties: any[];
            staticProperties: any[];
            staticStride: number;
            staticBuffer: any;
            staticData: any;
            staticDataUint32: any;
            dynamicStride: number;
            dynamicBuffer: any;
            dynamicData: any;
            dynamicDataUint32: any;

            protected _updateID: number;

            destroy(): void;
        }
        interface ParticleRendererProperty {
            attribute: number;
            size: number;
            uploadFunction(
                children: PIXI.DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            unsignedByte: any;
            offset: number;
        }
        class ParticleRenderer extends ObjectRenderer {
            constructor(renderer: WebGLRenderer);

            shader: glCore.GLShader;
            indexBuffer: WebGLBuffer;
            properties: ParticleRendererProperty[];
            protected tempMatrix: Matrix;

            start(): void;
            generateBuffers(container: ParticleContainer): ParticleBuffer[];
            protected _generateOneMoreBuffer(container: ParticleContainer): ParticleBuffer;
            uploadVertices(
                children: DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            uploadPosition(
                children: DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            uploadRotation(
                children: DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            uploadUvs(
                children: DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            uploadTint(
                children: DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            uploadAlpha(
                children: DisplayObject[],
                startIndex: number,
                amount: number,
                array: number[],
                stride: number,
                offset: number
            ): void;
            destroy(): void;

            indices: Uint16Array;
        }
    }
    //////////////////////////////////////////////////////////////////////////////
    ////////////////////////////PREPARE///////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////
    namespace prepare {
        type AddHook = (item: any, queue: any[]) => boolean;
        type UploadHook<UploadHookSource> = (prepare: UploadHookSource, item: any) => boolean;
        abstract class BasePrepare<UploadHookSource> {
            constructor(renderer: SystemRenderer);

            limiter: CountLimiter | TimeLimiter;
            protected renderer: SystemRenderer;
            protected uploadHookHelper: UploadHookSource;
            protected queue: any[];
            protected addHooks: AddHook[];
            protected uploadHooks: Array<UploadHook<UploadHookSource>>;
            protected completes: (...args: any[]) => any[];
            protected ticking: boolean;
            protected delayedTick: () => void;

            //tslint:disable-next-line:ban-types forbidden-types
            upload(
                item: Function | DisplayObject | Container | BaseTexture | Texture | Graphics | Text | any,
                done?: () => void
            ): void;
            protected tick(): void;
            protected prepareItems(): void;
            registerFindHook(addHook: AddHook): this;
            registerUploadHook(uploadHook: UploadHook<UploadHookSource>): this;
            protected findMultipleBaseTextures(item: PIXI.DisplayObject, queue: any[]): boolean;
            protected findBaseTexture(item: PIXI.DisplayObject, queue: any[]): boolean;
            protected findTexture(item: PIXI.DisplayObject, queue: any[]): boolean;
            add(
                item:
                    | PIXI.DisplayObject
                    | PIXI.Container
                    | PIXI.BaseTexture
                    | PIXI.Texture
                    | PIXI.Graphics
                    | PIXI.Text
                    | any
            ): this;
            destroy(): void;
        }
        class CanvasPrepare extends BasePrepare<CanvasPrepare> {
            constructor(renderer: CanvasRenderer);

            protected canvas: HTMLCanvasElement;
            protected ctx: CanvasRenderingContext2D;
        }
        class WebGLPrepare extends BasePrepare<WebGLRenderer> {
            constructor(renderer: WebGLRenderer);
        }
        class CountLimiter {
            constructor(maxItemsPerFrame: number);

            protected maxItemsPerFrame: number;
            protected itemsLeft: number;

            beginFrame(): void;
            allowedToUpload(): boolean;
        }
        class TimeLimiter {
            constructor(maxMilliseconds: number);

            protected maxMilliseconds: number;
            protected frameStart: number;

            beginFrame(): void;
            allowedToUpload(): boolean;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    /////////////////////////////pixi-gl-core/////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////
    // pixi-gl-core 1.1.4 https://github.com/pixijs/pixi-gl-core
    // sharedArrayBuffer as a type is not available yet.
    // need to fully define what an `Attrib` is.
    namespace glCore {
        interface ContextOptions {
            /**
             * Boolean that indicates if the canvas contains an alpha buffer.
             */
            alpha?: boolean;
            /**
             * Boolean that indicates that the drawing buffer has a depth buffer of at least 16 bits.
             */
            depth?: boolean;
            /**
             * Boolean that indicates that the drawing buffer has a stencil buffer of at least 8 bits.
             */
            stencil?: boolean;
            /**
             * Boolean that indicates whether or not to perform anti-aliasing.
             */
            antialias?: boolean;
            /**
             * Boolean that indicates that the page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
             */
            premultipliedAlpha?: boolean;
            /**
             * If the value is true the buffers will not be cleared and will preserve their values until cleared or overwritten by the author.
             */
            preserveDrawingBuffer?: boolean;
            /**
             *  Boolean that indicates if a context will be created if the system performance is low.
             */
            failIfMajorPerformanceCaveat?: boolean;
        }
        function createContext(view: HTMLCanvasElement, options?: ContextOptions): WebGLRenderingContext;
        function setVertexAttribArrays(
            gl: WebGLRenderingContext,
            attribs: Attrib[],
            state?: WebGLState
        ): WebGLRenderingContext | undefined;
        class GLBuffer {
            constructor(
                gl: WebGLRenderingContext,
                type: number,
                data: ArrayBuffer | ArrayBufferView | any,
                drawType: number
            );

            protected _updateID?: number;
            gl: WebGLRenderingContext;
            buffer: WebGLBuffer;
            type: number;
            drawType: number;
            data: ArrayBuffer | ArrayBufferView | any;

            upload(data?: ArrayBuffer | ArrayBufferView | any, offset?: number, dontBind?: boolean): void;
            bind(): void;

            static createVertexBuffer(
                gl: WebGLRenderingContext,
                data: ArrayBuffer | ArrayBufferView | any,
                drawType: number
            ): GLBuffer;
            static createIndexBuffer(
                gl: WebGLRenderingContext,
                data: ArrayBuffer | ArrayBufferView | any,
                drawType: number
            ): GLBuffer;
            static create(
                gl: WebGLRenderingContext,
                type: number,
                data: ArrayBuffer | ArrayBufferView | any,
                drawType: number
            ): GLBuffer;

            destroy(): void;
        }
        class GLFramebuffer {
            constructor(gl: WebGLRenderingContext, width: number, height: number);

            gl: WebGLRenderingContext;
            frameBuffer: WebGLFramebuffer;
            stencil: WebGLRenderbuffer;
            texture: GLTexture;
            width: number;
            height: number;

            enableTexture(texture: GLTexture): void;
            enableStencil(): void;
            clear(r: number, g: number, b: number, a: number): void;
            bind(): void;
            unbind(): void;
            resize(width: number, height: number): void;
            destroy(): void;

            static createRGBA(
                gl: WebGLRenderingContext,
                width: number,
                height: number,
                data: ArrayBuffer | ArrayBufferView | any
            ): GLFramebuffer;
            static createFloat32(
                gl: WebGLRenderingContext,
                width: number,
                height: number,
                data: ArrayBuffer | ArrayBufferView | any
            ): GLFramebuffer;
        }
        class GLShader {
            constructor(
                gl: WebGLRenderingContext,
                vertexSrc: string | string[],
                fragmentSrc: string | string[],
                precision?: string,
                attributeLocations?: { [key: string]: number }
            );

            gl: WebGLRenderingContext;
            program?: WebGLProgram | null;
            uniformData: any;
            uniforms: any;
            attributes: any;

            bind(): this;
            destroy(): void;
        }
        class GLTexture {
            constructor(gl: WebGLRenderingContext, width?: number, height?: number, format?: number, type?: number);

            gl: WebGLRenderingContext;
            texture: WebGLTexture;
            mipmap: boolean;
            premultiplyAlpha: boolean;
            width: number;
            height: number;
            format: number;
            type: number;

            upload(source: HTMLImageElement | ImageData | HTMLVideoElement | HTMLCanvasElement): void;
            uploadData(data: ArrayBuffer | ArrayBufferView, width: number, height: number): void;
            bind(location?: number): void;
            unbind(): void;
            minFilter(linear: boolean): void;
            magFilter(linear: boolean): void;
            enableMipmap(): void;
            enableLinearScaling(): void;
            enableNearestScaling(): void;
            enableWrapClamp(): void;
            enableWrapRepeat(): void;
            enableWrapMirrorRepeat(): void;
            destroy(): void;

            static fromSource(
                gl: WebGLRenderingContext,
                source: HTMLImageElement | ImageData | HTMLVideoElement | HTMLCanvasElement,
                premultipleAlpha?: boolean
            ): GLTexture;
            static fromData(gl: WebGLRenderingContext, data: number[], width: number, height: number): GLTexture;
        }
        interface Attrib {
            attribute: {
                location: number;
                size: number;
            };
            normalized: boolean;
            stride: number;
            start: number;
            buffer: ArrayBuffer;
        }
        interface WebGLRenderingContextAttribute {
            buffer: WebGLBuffer;
            attribute: any;
            type: number;
            normalized: boolean;
            stride: number;
            start: number;
        }
        interface AttribState {
            tempAttribState: Attrib[];
            attribState: Attrib[];
        }
        class VertexArrayObject {
            static FORCE_NATIVE: boolean;

            constructor(gl: WebGLRenderingContext, state?: WebGLState);

            protected nativeVaoExtension: any;
            protected nativeState: AttribState;
            protected nativeVao: VertexArrayObject;
            gl: WebGLRenderingContext;
            attributes: Attrib[];
            indexBuffer: GLBuffer;
            dirty: boolean;

            bind(): this;
            unbind(): this;
            activate(): this;
            addAttribute(
                buffer: GLBuffer,
                attribute: Attrib,
                type?: number,
                normalized?: boolean,
                stride?: number,
                start?: number
            ): this;
            addIndex(buffer: GLBuffer, options?: any): this;
            clear(): this;
            draw(type: number, size: number, start: number): this;
            destroy(): void;
        }
    }

    //////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////UTILS//////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////

    interface DecomposedDataUri {
        mediaType: string;
        subType: string;
        encoding: string;
        data: any;
    }

    namespace utils {
        function uid(): number;
        function hex2rgb(hex: number, out?: number[]): number[];
        function hex2string(hex: number): string;
        function rgb2hex(rgb: number[]): number;
        function canUseNewCanvasBlendModes(): boolean;
        function getResolutionOfUrl(url: string, defaultValue?: number): number;
        function getSvgSize(svgString: string): any;
        function decomposeDataUri(dataUri: string): DecomposedDataUri | void;
        function getUrlFileExtension(url: string): string | void;
        function sayHello(type: string): void;
        function skipHello(): void;
        function isWebGLSupported(): boolean;
        function sign(n: number): number;
        /**
         * Remove a range of items from an array
         *
         * @param arr The target array
         * @param startIdx The index to begin removing from (inclusive)
         * @param removeCount How many items to remove
         */
        function removeItems<T>(arr: T[], startIdx: number, removeCount: number): void;
        function correctBlendMode(blendMode: number, premultiplied: boolean): number;
        function clearTextureCache(): void;
        function destroyTextureCache(): void;
        function premultiplyTint(tint: number, alpha: number): number;
        function premultiplyRgba(
            rgb: Float32Array | number[],
            alpha: number,
            out?: Float32Array,
            premultiply?: boolean
        ): Float32Array;
        function premultiplyTintToRgba(
            tint: number,
            alpha: number,
            out?: Float32Array,
            premultiply?: boolean
        ): Float32Array;
        const premultiplyBlendMode: number[][];
        const TextureCache: any;
        const BaseTextureCache: any;

        // https://github.com/kaimallea/isMobile
        namespace isMobile {
            const apple: {
                phone: boolean;
                ipod: boolean;
                tablet: boolean;
                device: boolean;
            };
            const android: {
                phone: boolean;
                tablet: boolean;
                device: boolean;
            };
            const amazon: {
                phone: boolean;
                tablet: boolean;
                device: boolean;
            };
            const windows: {
                phone: boolean;
                tablet: boolean;
                device: boolean;
            };
            const seven_inch: boolean;
            const other: {
                blackberry10: boolean;
                blackberry: boolean;
                opera: boolean;
                firefox: boolean;
                chrome: boolean;
                device: boolean;
            };
            const any: boolean;
            const phone: boolean;
            const tablet: boolean;
        }
        // https://github.com/primus/eventemitter3
        class EventEmitter {
            static prefixed: string | boolean;
            static EventEmitter: {
                new (): EventEmitter;
                prefixed: string | boolean;
            };
            /**
             * Minimal EventEmitter interface that is molded against the Node.js
             * EventEmitter interface.
             *
             * @constructor
             * @api public
             */
            constructor();
            /**
             * Return an array listing the events for which the emitter has registered listeners.
             *
             * @returns
             */
            eventNames(): Array<string | symbol>;
            /**
             * Return the listeners registered for a given event.
             *
             * @param {(string | symbol)} event The event name.
             * @returns
             */
            //tslint:disable-next-line:ban-types forbidden-types
            listeners(event: string | symbol): Function[];
            /**
             * Check if there listeners for a given event.
             * If `exists` argument is not `true` lists listeners.
             *
             * @param event The event name.
             * @param exists Only check if there are listeners.
             * @returns
             */
            listeners(event: string | symbol, exists: boolean): boolean;
            /**
             * Calls each of the listeners registered for a given event.
             *
             * @param event The event name.
             * @param args Arguments that are passed to registered listeners
             * @returns `true` if the event had listeners, else `false`.
             */
            emit(event: string | symbol, ...args: any[]): boolean;
            /**
             * Add a listener for a given event.
             *
             * @param event The event name.
             * @param fn The listener function.
             * @param [context=this] The context to invoke the listener with.
             * @returns `this`
             */
            on(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
            /**
             * Add a one-time listener for a given event.
             *
             * @param event The event name.
             * @param fn The listener function.
             * @param [context=this] The context to invoke the listener with.
             * @returns `this`
             */
            once(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
            /**
             * Remove the listeners of a given event.
             *
             * @param event The event name.
             * @param fn Only remove the listeners that match this function.
             * @param context Only remove the listeners that have this context.
             * @param once Only remove one-time listeners.
             * @returns `this`
             */
            removeListener(event: string | symbol, fn?: (...args: any[]) => any, context?: any, once?: boolean): this;
            /**
             * Remove all listeners, or those of the specified event.
             *
             * @param event The event name.
             * @returns `this`.
             */
            removeAllListeners(event?: string | symbol): this;
            /**
             * Alias method for `removeListener`
             */
            off(event: string | symbol, fn?: (...args: any[]) => any, context?: any, once?: boolean): this;
            /**
             * Alias method for `on`
             */
            addListener(event: string | symbol, fn: (...args: any[]) => any, context?: any): this;
            /**
             * This function doesn"t apply anymore.
             * @deprecated
             */
            setMaxListeners(): this;
        }
    }
    //////////////////////////////////////////////////////////////////////////////
    /////////////////////////////depreciation/////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////
    // not sure how to handle blendmodes scalemodes basetexturecache
    namespace core {
        /**
         * @class
         * @private
         * @name SpriteBatch
         * @memberof PIXI
         * @see PIXI.ParticleContainer
         * @throws {ReferenceError} SpriteBatch does not exist any more, please use the new ParticleContainer instead.
         * @deprecated since version 3.0.0
         */
        type SpriteBatch = ParticleContainer;

        /**
         * @class
         * @private
         * @name AssetLoader
         * @memberof PIXI
         * @see PIXI.loaders.Loader
         * @throws {ReferenceError} The loader system was overhauled in pixi v3, please see the new PIXI.loaders.Loader class.
         * @deprecated since version 3.0.0
         */
        type AssetLoader = loaders.Loader;

        /**
         * @class
         * @private
         * @name Stage
         * @memberof PIXI
         * @see PIXI.Container
         * @deprecated since version 3.0.0
         */
        type Stage = Container;

        /**
         * @class
         * @private
         * @name DisplayObjectContainer
         * @memberof PIXI
         * @see PIXI.Container
         * @deprecated since version 3.0.0
         */
        type DisplayObjectContainer = Container;

        /**
         * @class
         * @private
         * @name Strip
         * @memberof PIXI
         * @see PIXI.mesh.Mesh
         * @deprecated since version 3.0.0
         */
        type Strip = mesh.Mesh;

        /**
         * @class
         * @private
         * @name Rope
         * @memberof PIXI
         * @see PIXI.mesh.Rope
         * @deprecated since version 3.0.0
         */
        type Rope = mesh.Rope;

        /**
         * @class
         * @private
         * @name ParticleContainer
         * @memberof PIXI
         * @see PIXI.particles.ParticleContainer
         * @deprecated since version 4.0.0
         */
        type ParticleContainer = particles.ParticleContainer;

        /**
         * @class
         * @private
         * @name MovieClip
         * @memberof PIXI
         * @see PIXI.extras.MovieClip
         * @deprecated since version 3.0.0
         */
        type MovieClip = extras.AnimatedSprite;

        /**
         * @class
         * @private
         * @name TilingSprite
         * @memberof PIXI
         * @see PIXI.extras.TilingSprite
         * @deprecated since version 3.0.0
         */
        type TilingSprite = extras.TilingSprite;

        /**
         * @class
         * @private
         * @name BaseTextureCache
         * @memberof PIXI
         * @see PIXI.utils.BaseTextureCache
         * @deprecated since version 3.0.0
         */
        type BaseTextureCache = any;

        /**
         * @class
         * @private
         * @name BitmapText
         * @memberof PIXI
         * @see PIXI.extras.BitmapText
         * @deprecated since version 3.0.0
         */
        type BitmapText = extras.BitmapText;

        /**
         * @namespace
         * @private
         * @name math
         * @memberof PIXI
         * @see PIXI
         * @deprecated since version 3.0.6
         */
        type math = any;

        /**
         * @class
         * @private
         * @name PIXI.AbstractFilter
         * @see PIXI.Filter
         * @deprecated since version 3.0.6
         */
        type AbstractFilter<U extends Object> = Filter<U>;

        /**
         * @class
         * @private
         * @name PIXI.TransformManual
         * @see PIXI.TransformBase
         * @deprecated since version 4.0.0
         */
        type TransformManual = TransformBase;

        /**
         * @static
         * @constant
         * @name PIXI.TARGET_FPMS
         * @see PIXI.settings.TARGET_FPMS
         * @deprecated since version 4.2.0
         */
        type TARGET_FPMS = number;

        /**
         * @static
         * @constant
         * @name PIXI.FILTER_RESOLUTION
         * @see PIXI.settings.FILTER_RESOLUTION
         * @deprecated since version 4.2.0
         */
        type FILTER_RESOLUTION = number;

        /**
         * @static
         * @constant
         * @name PIXI.RESOLUTION
         * @see PIXI.settings.RESOLUTION
         * @deprecated since version 4.2.0
         */
        type RESOLUTION = number;

        /**
         * @static
         * @constant
         * @name PIXI.MIPMAP_TEXTURES
         * @see PIXI.settings.MIPMAP_TEXTURES
         * @deprecated since version 4.2.0
         */
        type MIPMAP_TEXTURES = any;

        /**
         * @static
         * @constant
         * @name PIXI.SPRITE_BATCH_SIZE
         * @see PIXI.settings.SPRITE_BATCH_SIZE
         * @deprecated since version 4.2.0
         */
        type SPRITE_BATCH_SIZE = number;

        /**
         * @static
         * @constant
         * @name PIXI.SPRITE_MAX_TEXTURES
         * @see PIXI.settings.SPRITE_MAX_TEXTURES
         * @deprecated since version 4.2.0
         */
        type SPRITE_MAX_TEXTURES = number;

        /**
         * @static
         * @constant
         * @name PIXI.RETINA_PREFIX
         * @see PIXI.settings.RETINA_PREFIX
         * @deprecated since version 4.2.0
         */
        type RETINA_PREFIX = RegExp | string;

        /**
         * @static
         * @constant
         * @name PIXI.DEFAULT_RENDER_OPTIONS
         * @see PIXI.settings.RENDER_OPTIONS
         * @deprecated since version 4.2.0
         */
        type DEFAULT_RENDER_OPTIONS = number;

        /**
         * @static
         * @name PRECISION
         * @memberof PIXI.settings
         * @see PIXI.PRECISION
         * @deprecated since version 4.4.0
         */
        type PRECISION = string;
    }

    namespace GroupD8 {
        /**
         * @name PIXI.GroupD8.isSwapWidthHeight
         * @see PIXI.GroupD8.isVertical
         * @param rotation - The number to check.
         * @returns Whether or not the direction is vertical
         * @deprecated since version 4.6.0
         */
        function isSwapWidthHeight(rotation: number): boolean;
    }

    namespace extras {
        /**
         * @class
         * @name MovieClip
         * @memberof PIXI.extras
         * @see PIXI.extras.AnimatedSprite
         * @deprecated since version 4.2.0
         */
        type MovieClip = extras.AnimatedSprite;

        /**
         * @class
         * @name TextureTransform
         * @memberof PIXI.extras
         * @see PIXI.TextureMatrix
         * @deprecated since version 4.6.0
         */
        type TextureTranform = TextureMatrix;
    }

    namespace filters {
        /**
         * @class
         * @private
         * @name PIXI.filters.VoidFilter
         * @see PIXI.filters.AlphaFilter
         * @deprecated since version 4.5.7
         */
        type VoidFilter = filters.AlphaFilter;
    }

    namespace settings {
        /**
         * @static
         * @name PRECISION
         * @memberof PIXI.settings
         * @see PIXI.PRECISION
         * @deprecated since version 4.4.0
         */
        type PRECISION = number;
    }
}

declare namespace pixi {
    const gl: typeof PIXI.glCore;
}

//tslint:disable-next-line:no-single-declare-module
declare module "pixi.js" {
    export = PIXI;
}