export interface WatermarkOptions {
    /**
     * Whether this package reconciles the container against the page licence.
     *
     * True (the default) suits a wholly-premium product: the whole chart is
     * licensed, so "no valid licence" and "should be watermarked" are the same
     * question, and reconciling here means the product needs no code of its own.
     *
     * Pass false when the product decides for itself. ApexCharts does: it
     * watermarks only when a *premium feature* is actually in use, and it resolves
     * a per-instance `chart.license` key that can differ from the page-wide one.
     * Both make the licence state an input to its decision rather than the whole
     * of it, so reconciling here would paint free charts and erase watermarks the
     * product deliberately applied.
     */
    manage?: boolean;
}
export declare class Watermark {
    private static readonly WATERMARK_ATTR;
    private static readonly WATERMARK_TEXT;
    /**
     * The marker attribute, exposed so a product can watch for tampering.
     *
     * ApexCharts runs two MutationObservers off this: one on the overlay's style
     * attribute, restoring it through `applyStyles` when it is edited, and one on
     * the wrapper, re-adding the overlay when the node is deleted. Both need to
     * find the node, which is why `node` and `applyStyles` are public rather than
     * folded into `paint`.
     */
    static readonly ATTR = "data-apexcharts-watermark";
    /**
     * The styles that make the overlay an overlay.
     *
     * Split out from `paint` so a tamper observer can restore them on the
     * existing node without rebuilding it, which would invalidate the very
     * observer doing the restoring.
     */
    private static readonly CRITICAL_STYLES;
    /**
     * Re-apply the overlay's critical styles and pattern to an existing node.
     *
     * @param el The watermark node, as returned by `node`.
     */
    static applyStyles(el: HTMLElement): void;
    /** The watermark node inside a container, if it has one. */
    static node(container: HTMLElement | null | undefined): HTMLElement | null;
    /**
     * Containers whose watermark follows the licence state.
     *
     * Signature verification settles asynchronously, and every product decides the
     * watermark synchronously while rendering (`isLicenseValid() ? remove : add`).
     * Without reconciliation a forged key would escape the watermark entirely in the
     * ordinary `setLicense(key)` then `render()` sequence, because nothing would ask
     * again after verification failed. Tracking the containers here lets that
     * correction happen inside this package, so no product needs to change.
     *
     * This assumes the watermark is licence-driven, which it is in every Apex
     * product. A caller using it for anything else should call `untrack`.
     */
    private static managed;
    private static subscribed;
    /**
     * Add a watermark to a container, and keep it in step with the licence state.
     *
     * No-op without a container or a document, so a product can call this from
     * shared render code that also runs under server-side rendering.
     *
     * @returns The watermark node, or null when there was nothing to paint on.
     */
    static add(container: HTMLElement | null | undefined, options?: WatermarkOptions): HTMLElement | null;
    /** Whether a watermark is present in the container. */
    static exists(container: HTMLElement | null | undefined): boolean;
    /**
     * Remove the watermark from a container, and keep it in step with the licence
     * state.
     */
    static remove(container: HTMLElement | null | undefined, options?: WatermarkOptions): void;
    /**
     * Stop reconciling this container, for a caller driving the watermark itself.
     */
    static untrack(container: HTMLElement): void;
    /**
     * Create a repeating diagonal watermark pattern
     */
    private static createWatermarkPattern;
    private static erase;
    private static paint;
    /** Re-apply the licence decision to every tracked container. */
    private static reconcile;
    /** Opt a container into or out of licence reconciliation for this call. */
    private static setManaged;
    private static track;
}
//# sourceMappingURL=Watermark.d.ts.map