import '../../../globals.js';
/**
 * A node that displays a single image either from an actual HTMLImageElement, a URL, a Canvas element, or a mipmap
 * data structure described in the constructor.
 *
 * @author Jonathan Olson <jonathan.olson@colorado.edu>
 */
import TReadOnlyProperty from '../../../axon/js/TReadOnlyProperty.js';
import Bounds2 from '../../../dot/js/Bounds2.js';
import Matrix3 from '../../../dot/js/Matrix3.js';
import Vector2 from '../../../dot/js/Vector2.js';
import { Shape } from '../../../kite/js/imports.js';
import IOType from '../../../tandem/js/types/IOType.js';
import { CanvasContextWrapper, CanvasSelfDrawable, DOMSelfDrawable, ImageableImage, ImageableOptions, Instance, Node, NodeOptions, SVGSelfDrawable, WebGLSelfDrawable } from '../imports.js';
type SelfOptions = {
    imageBounds?: Bounds2 | null;
};
type ParentOptions = NodeOptions & ImageableOptions;
export type ImageOptions = SelfOptions & ParentOptions;
declare const Image_base: typeof Node & import("../../../phet-core/js/types/Constructor.js").default<import("./Imageable.js").TImageable>;
export default class Image extends Image_base {
    private _imageBounds;
    constructor(image: ImageableImage | TReadOnlyProperty<ImageableImage>, providedOptions?: ImageOptions);
    /**
     * Triggers recomputation of the image's bounds and refreshes any displays output of the image.
     *
     * Generally this can trigger recomputation of mipmaps, will mark any drawables as needing repaints, and will
     * cause a spritesheet change for WebGL.
     *
     * This should be done when the underlying image has changed appearance (usually the case with a Canvas changing,
     * but this is also triggered by our actual image reference changing).
     */
    invalidateImage(): void;
    /**
     * Recomputes what renderers are supported, given the current image information.
     */
    invalidateSupportedRenderers(): void;
    /**
     * Sets an opacity that is applied only to this image (will not affect children or the rest of the node's subtree).
     *
     * This should generally be preferred over Node's opacity if it has the same result, as modifying this will be much
     * faster, and will not force additional Canvases or intermediate steps in display.
     *
     * @param imageOpacity - Should be a number between 0 (transparent) and 1 (opaque), just like normal opacity.
     */
    setImageOpacity(imageOpacity: number): void;
    /**
     * Sets the imageBounds value for the Image. If non-null, determines what is considered "inside" the image for
     * containment and hit-testing.
     *
     * NOTE: This is accomplished by using any provided imageBounds as the node's own selfBounds. This will affect layout,
     * hit-testing, and anything else using the bounds of this node.
     */
    setImageBounds(imageBounds: Bounds2 | null): void;
    set imageBounds(value: Bounds2 | null);
    get imageBounds(): Bounds2 | null;
    /**
     * Returns the imageBounds, see setImageBounds for details.
     */
    getImageBounds(): Bounds2 | null;
    /**
     * Whether this Node itself is painted (displays something itself).
     */
    isPainted(): boolean;
    /**
     * Draws the current Node's self representation, assuming the wrapper's Canvas context is already in the local
     * coordinate frame of this node.
     *
     * @param wrapper
     * @param matrix - The transformation matrix already applied to the context.
     */
    protected canvasPaintSelf(wrapper: CanvasContextWrapper, matrix: Matrix3): void;
    /**
     * Creates a DOM drawable for this Image. (scenery-internal)
     *
     * @param renderer - In the bitmask format specified by Renderer, which may contain additional bit flags.
     * @param instance - Instance object that will be associated with the drawable
     */
    createDOMDrawable(renderer: number, instance: Instance): DOMSelfDrawable;
    /**
     * Creates a SVG drawable for this Image. (scenery-internal)
     *
     * @param renderer - In the bitmask format specified by Renderer, which may contain additional bit flags.
     * @param instance - Instance object that will be associated with the drawable
     */
    createSVGDrawable(renderer: number, instance: Instance): SVGSelfDrawable;
    /**
     * Creates a Canvas drawable for this Image. (scenery-internal)
     *
     * @param renderer - In the bitmask format specified by Renderer, which may contain additional bit flags.
     * @param instance - Instance object that will be associated with the drawable
     */
    createCanvasDrawable(renderer: number, instance: Instance): CanvasSelfDrawable;
    /**
     * Creates a WebGL drawable for this Image. (scenery-internal)
     *
     * @param renderer - In the bitmask format specified by Renderer, which may contain additional bit flags.
     * @param instance - Instance object that will be associated with the drawable
     */
    createWebGLDrawable(renderer: number, instance: Instance): WebGLSelfDrawable;
    /**
     * Override this for computation of whether a point is inside our self content (defaults to selfBounds check).
     *
     * @param point - Considered to be in the local coordinate frame
     */
    containsPointSelf(point: Vector2): boolean;
    /**
     * Returns a Shape that represents the area covered by containsPointSelf.
     */
    getSelfShape(): Shape;
    /**
     * Triggers recomputation of mipmaps (as long as mipmapping is enabled)
     */
    invalidateMipmaps(): void;
    mutate(options?: ImageOptions): this;
    static ImageIO: IOType;
    static readonly DEFAULT_IMAGE_OPTIONS: ImageOptions;
}
export {};
//# sourceMappingURL=Image.d.ts.map