import { ContextManager, Context } from '../context';
import { Event } from '../event';
import { Observable } from '../observable';
/**
 * Defines options for initializing a `CanvasContext`.
 * - `canvas`: Optional HTMLCanvasElement to be managed.
 * - `overlay`: Optional HTMLDivElement to be used as an overlay.
 */
export interface CanvasContextOptions {
    canvas?: HTMLCanvasElement;
    overlay?: HTMLDivElement;
}
/**
 * Manages a canvas and an overlay within a context, providing events and observables for canvas rendering and resizing.
 * - `onBeforeRender`: Event triggered before rendering the canvas.
 * - `onAfterRender`: Event triggered after rendering the canvas.
 * - `canvas`: The HTMLCanvasElement being managed.
 * - `overlayDefault`: Default HTMLDivElement used as an overlay.
 * - `overlay`: Observable for the overlay element.
 * - `size`: Observable for the canvas size, updated on resize.
 * @zcontext
 * */
export declare class CanvasContext extends Context {
    constructorProps: CanvasContextOptions;
    readonly onBeforeRender: Event<[number]>;
    readonly onAfterRender: Event<[number]>;
    readonly canvas: HTMLCanvasElement;
    readonly overlayDefault: HTMLDivElement;
    readonly overlay: Observable<HTMLDivElement>;
    /** @zui */
    readonly size: Observable<[number, number]>;
    private _resizeObserver;
    /**
     * Creates an instance of CanvasContext.
     * @param contextManager - The current ContextManager
     * @param constructorProps - The constructor properties.
     */
    constructor(contextManager: ContextManager, constructorProps: CanvasContextOptions);
    /**
     * Captures the canvas content and returns it as a Data URL after the current frame has rendered.
     * @param type The MIME image format type.
     * @param quality Between 0 and 1 indicating image quality. Defaults to 1.
     */
    captureToDataURL(type?: 'image/png' | 'image/jpeg', quality?: number): Promise<string>;
    /**
     * Captures the canvas content and returns it as an ArrayBuffer after the current frame has rendered.
     * @param type The MIME image format type.
     * @param quality Between 0 and 1 indicating image quality. Defaults to 1.
     */
    captureToArrayBuffer(type?: 'image/png' | 'image/jpeg', quality?: number): Promise<ArrayBuffer>;
    private canvasToBlob;
    private blobToArrayBuffer;
    dispose(): never;
}
/**
 * Enum representing horizontal alignment options: 'left', 'center', 'right'.
 */
export declare enum HorizontalAlignment {
    'left' = "left",
    'leftSafe' = "leftSafe",
    'center' = "center",
    'right' = "right",
    'rightSafe' = "rightSafe"
}
/**
 * Enum representing vertical alignment options: 'top', 'center', 'bottom', 'topSafe', 'bottomSafe'.
 */
export declare enum VerticalAlignment {
    'top' = "top",
    'topSafe' = "topSafe",
    'center' = "center",
    'bottom' = "bottom",
    'bottomSafe' = "bottomSafe"
}
/**
 * Retrieves the canvas element from the `CanvasContext`.
 * @param {ContextManager} mgr The context manager instance.
 * @returns {HTMLCanvasElement} The canvas element managed by `CanvasContext`.
 */
export declare function useCanvas(mgr: ContextManager): HTMLCanvasElement;
/**
 * Retrieves the overlay element from the `CanvasContext`.
 * @param {ContextManager} mgr The context manager instance.
 * @returns {Observable<HTMLDivElement>} The overlay element as an observable managed by `CanvasContext`.
 */
export declare function useOverlay(mgr: ContextManager): Observable<HTMLDivElement, never>;
/**
 * Retrieves the size of the canvas from the `CanvasContext`.
 * @param {ContextManager} mgr - The context manager.
 * @returns {Size} The size of the canvas.
 */
export declare function useCanvasSize(mgr: ContextManager): Observable<[number, number], never>;
/**
 * Retrieves the onBeforeRender event from the `CanvasContext`. This event is fired before the canvas is rendered.
 *
 * `this.register(useOnBeforeRender(this.contextManager), ()=>{  });`
 * @param {ContextManager} mgr - The context manager.
 * @returns {Function} The onBeforeRender function.
 */
export declare function useOnBeforeRender(mgr: ContextManager): Event<[number]>;
/**
 * Retrieves the onAfterRender event from the `CanvasContext`.
 * @param {ContextManager} mgr The context manager instance.
 * @returns {Event<[number]>} The onAfterRender event, triggered after canvas rendering.
 */
export declare function useOnAfterRender(mgr: ContextManager): Event<[number]>;
/**
 * Returns a promise that resovles a data url of the canvas as jpeg.
 *
 * For custom MIME types or quality settings, use`contextManager.get(CanvasContext).captureToDataURL();`
 */
export declare function useCanvasToDataURL(mgr: ContextManager): Promise<string>;
/**
 * Returns a promise that resolves an array buffer of the canvas image.
 *
 * For custom MIME types or quality settings, use`contextManager.get(CanvasContext).captureToArrayBuffer();`
 */
export declare function useCanvasToArrayBuffer(mgr: ContextManager): Promise<ArrayBuffer>;
/**
 * Generates class names for alignment based on specified horizontal and vertical alignment values.
 * @param {HorizontalAlignment} h The horizontal alignment value.
 * @param {VerticalAlignment} v The vertical alignment value.
 * @returns {string} A string of class names for the specified alignments.
 */
export declare function classNameForAlignment(h: HorizontalAlignment, v: VerticalAlignment): string;