import { DisplaySymbol, EagerlyResolvedSymbol, SymbolData } from "../symbol";
import { ImageType, Bounds } from "../../base/utilities";
import { ISecurityDomain } from "../../avm2/nat/ISecurityDomain";
import { ASObject } from "../../avm2/nat/ASObject";
import { Matrix } from "../geom/Matrix";
import { Rectangle } from "../geom/Rectangle";
import { ColorTransform } from "../geom/ColorTransform";
import { Bitmap } from "./Bitmap";
import { GenericVector } from "../../avm2/natives/GenericVector";
import { Uint32Vector } from "../../avm2/natives/uint32Vector";
import { ByteArray } from "../../avm2/natives/byteArray";
import { Point } from "../geom/Point";
import { IBitmapDrawable } from "./IBitmapDrawable";
import { IRemotable } from "../../base/remoting";
import { DataBuffer } from "@awayjs/graphics";
import { BitmapFilter } from "../filters/BitmapFilter";
import { LoaderInfo } from "./LoaderInfo";
import { AXClass } from '../../avm2/run/AXClass';
/**
 * Holds blobs of bitmap data in various formats and lets you do basic pixel operations. When
 * data is unpacked, it is stored as premultiplied ARGB since it's what the SWF encodes bitmaps
 * as.  This way we don't have to do unecessary byte conversions.
 */
export declare class BitmapData extends ASObject implements IBitmapDrawable, IRemotable {
    static axClass: typeof BitmapData & AXClass;
    static classInitializer(): void;
    _symbol: BitmapSymbol;
    applySymbol(): void;
    static MAXIMUM_WIDTH: number;
    static MAXIMUM_HEIGHT: number;
    static MAXIMUM_DIMENSION: number;
    constructor(width: number, height: number, transparent?: boolean, fillColorARGB?: number);
    private _setData;
    /**
     * Back references to Bitmaps that use this BitmapData. These objects need to be marked as dirty
     * when this bitmap data becomes dirty.
     */
    private _bitmapReferrers;
    _addBitmapReferrer(bitmap: Bitmap): void;
    _removeBitmapReferrer(bitmap: Bitmap): void;
    /**
     * Called whenever the contents of this bitmap data changes.
     */
    private _invalidate;
    _transparent: boolean;
    _rect: Rectangle;
    _id: number;
    _locked: boolean;
    /**
     * Image format stored in the |_data| buffer.
     */
    _type: ImageType;
    /**
     * Actual image bytes as raw pixel data of the format given by `_type`.
     */
    _data: Uint8Array;
    /**
     * Data buffer wrapped around the |_data| buffer.
     */
    _dataBuffer: DataBuffer;
    /**
     * Int32Array view on |_data| useful when working with 4 bytes at a time. Endianess is
     * important here, so if |_type| is PremultipliedAlphaARGB as is usually the case for
     * bitmap data, then |_view| values are actually BGRA (on little-endian machines).
     */
    _view: Int32Array;
    /**
     * Indicates whether this bitmap data's data buffer has changed since the last time it was
     * synchronized.
     */
    _isDirty: boolean;
    /**
     * Indicates whether this bitmap data's data buffer has changed on the remote end and needs to
     * be read back before any pixel operations can be performed.
     */
    _isRemoteDirty: boolean;
    /**
     * If non-null then this value indicates that the bitmap is filled with a solid color. This is
     * useful for optimizations.
     */
    _solidFillColorPBGRA: any;
    /**
     * Temporary rectangle that is used to prevent allocation.
     */
    private static _temporaryRectangle;
    private _getTemporaryRectangleFrom;
    getDataBuffer(): DataBuffer;
    _getContentBounds(): Bounds;
    /**
     * TODO: Not tested.
     */
    private _getPixelData;
    /**
     * TODO: Not tested.
     */
    private _putPixelData;
    get width(): number;
    get height(): number;
    get rect(): Rectangle;
    get transparent(): boolean;
    clone(): BitmapData;
    /**
     * Returns an straight alpha RGB pixel value 0x00RRGGBB.
     */
    getPixel(x: number, y: number): number;
    /**
     * Returns an straight alpha ARGB pixel value 0xAARRGGBB.
     */
    getPixel32(x: number, y: number): number;
    setPixel(x: number, y: number, uARGB: number): void;
    setPixel32(x: number, y: number, uARGB: number): void;
    applyFilter(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, filter: BitmapFilter): void;
    colorTransform(rect: Rectangle, colorTransform: ColorTransform): void;
    compare(otherBitmapData: BitmapData): ASObject;
    copyChannel(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, sourceChannel: number, destChannel: number): void;
    /**
     * Copies a rectangular region of pixels into the current bitmap data.
     */
    copyPixels(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, alphaBitmapData?: BitmapData, alphaPoint?: Point, mergeAlpha?: boolean): void;
    private _copyPixelsAndMergeAlpha;
    dispose(): void;
    draw(source: IBitmapDrawable, matrix?: Matrix, colorTransform?: ColorTransform, blendMode?: string, clipRect?: Rectangle, smoothing?: boolean): void;
    drawWithQuality(source: IBitmapDrawable, matrix?: Matrix, colorTransform?: ColorTransform, blendMode?: string, clipRect?: Rectangle, smoothing?: boolean, quality?: string): void;
    fillRect(rect: Rectangle, uARGB: number): void;
    floodFill(x: number, y: number, color: number): void;
    generateFilterRect(sourceRect: Rectangle, filter: BitmapFilter): Rectangle;
    getColorBoundsRect(mask: number, color: number, findColor?: boolean): Rectangle;
    getPixels(rect: Rectangle): ByteArray;
    copyPixelsToByteArray(rect: Rectangle, data: ByteArray): void;
    getVector(rect: Rectangle): Uint32Vector;
    hitTest(firstPoint: Point, firstAlphaThreshold: number, secondObject: ASObject, secondBitmapDataPoint?: Point, secondAlphaThreshold?: number): boolean;
    merge(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, redMultiplier: number, greenMultiplier: number, blueMultiplier: number, alphaMultiplier: number): void;
    noise(randomSeed: number, low?: number, high?: number, channelOptions?: number, grayScale?: boolean): void;
    paletteMap(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, redArray?: any[], greenArray?: any[], blueArray?: any[], alphaArray?: any[]): void;
    perlinNoise(baseX: number, baseY: number, numOctaves: number, randomSeed: number, stitch: boolean, fractalNoise: boolean, channelOptions?: number, grayScale?: boolean, offsets?: any[]): void;
    pixelDissolve(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, randomSeed?: number, numPixels?: number, fillColor?: number): number;
    scroll(x: number, y: number): void;
    setPixels(rect: Rectangle, inputByteArray: ByteArray): void;
    setVector(rect: Rectangle, inputVector: Uint32Vector): void;
    threshold(sourceBitmapData: BitmapData, sourceRect: Rectangle, destPoint: Point, operation: string, threshold: number, color?: number, mask?: number, copySource?: boolean): number;
    lock(): void;
    unlock(changeRect?: Rectangle): void;
    histogram(hRect?: Rectangle): GenericVector;
    encode(rect: Rectangle, compressor: ASObject, byteArray?: ByteArray): ByteArray;
    /**
     * Ensures that we have the most up-to-date version of the bitmap data. If a call to
     * |BitmpaData.draw| was made since the last time this method was called, then we need to send
     * a synchronous message to the GFX remote requesting the latest image data.
     *
     * Here we also normalize the image format to |ImageType.StraightAlphaRGBA|. We only need the
     * normalized pixel data for pixel operations, so we defer image decoding as late as possible.
     */
    private _ensureBitmapData;
}
export interface IBitmapDataSerializer {
    drawToBitmap(bitmapData: BitmapData, source: IBitmapDrawable, matrix: Matrix, colorTransform: ColorTransform, blendMode: string, clipRect: Rectangle, smoothing: boolean): any;
    requestBitmapData(bitmapData: BitmapData): DataBuffer;
}
export declare class BitmapSymbol extends DisplaySymbol implements EagerlyResolvedSymbol {
    width: number;
    height: number;
    syncId: number;
    data: Uint8Array;
    type: ImageType;
    private sharedInstance;
    constructor(data: SymbolData, sec: ISecurityDomain);
    static FromData(data: any, loaderInfo: LoaderInfo): BitmapSymbol;
    getSharedInstance(): any;
    createSharedInstance(): any;
    get resolveAssetCallback(): any;
    private _unboundResolveAssetCallback;
}