import { CharNode } from "../models";
import { GveRenditionSettings } from "../settings/settings";
import { OperationHint } from "../settings/hint-models";
import { Logger } from "../core/logger";
import { AnimationEngine } from "../animation/animation-engine";
import { BoundsCache } from "./bounds-cache";
import { SpreadingEngine } from "./spreading-engine";
import { HintOverrides } from "./feature-resolver";
/**
 * Hint renderer handles rendering of operation hints.
 * Hints are visual counterparts of editing operations.
 */
export declare class HintRenderer {
    private _settings;
    private _logger;
    private _animationEngine;
    private _boundsCache;
    private _spreadingEngine;
    constructor(settings: GveRenditionSettings, logger: Logger, animationEngine: AnimationEngine, boundsCache: BoundsCache, spreadingEngine: SpreadingEngine);
    /**
     * Render a hint for an operation.
     *
     * @param hintId - ID of the hint from settings.hints
     * @param hint - The hint configuration
     * @param referenceNodes - Nodes referenced by the operation (for RBR calculation)
     * @param rootSvg - Root SVG element to append hint to
     * @param variables - Variables from r_hint-vars for placeholder resolution
     * @param operationId - ID of the operation (for unique hint ID)
     * @param hintOrdinal - Ordinal number of this hint for the operation (1, 2, 3...)
     * @param allBaseNodes - All base text nodes (for displaced span)
     * @param versionTag - Version tag to add as CSS class
     * @param hintOverrides - Optional overrides from r_h-* features
     * @param panZoomInstance - The svg-pan-zoom instance (for prolog)
     * @param viewportWidth - Width of the visible viewport (for prolog)
     * @param viewportHeight - Height of the visible viewport (for prolog)
     * @returns Promise that resolves when rendering completes
     */
    renderHint(hintId: string, hint: OperationHint, referenceNodes: CharNode[], rootSvg: SVGElement, variables: Map<string, string>, operationId: string, hintOrdinal: number, allBaseNodes: CharNode[], versionTag: string, hintOverrides?: Map<string, HintOverrides>, panZoomInstance?: any, viewportWidth?: number, viewportHeight?: number): Promise<void>;
    /**
     * Calculate Reference Bounding Rectangles (RBRs) from reference nodes.
     * Nodes on different lines create separate RBRs.
     */
    private calculateRBRs;
    /**
     * Calculate RBRs from a displaced span reference (IDxN format).
     */
    private calculateDisplacedRBRs;
    /**
     * Calculate scaling information for the hint.
     * Returns scale factors and target dimensions.
     */
    private calculateScalingInfo;
    /**
     * Apply size transforms (scale and rotation) to the hint.
     * Per documentation, these are applied BEFORE positioning.
     *
     * IMPORTANT: We DON'T actually apply these as transforms on the element.
     * Instead, we just return the scaling info and rotation, and later we'll create
     * a combined transform that includes both sizing and positioning.
     */
    private applyHintSizeTransforms;
    /**
     * Apply complete transform to the hint (both sizing and positioning).
     * This builds a single transform that:
     * 1. Translates so the EBR alignment point is at origin
     * 2. Scales and rotates the hint
     * 3. Translates to the final RBR position
     *
     * Per documentation: hints use the handle's bounding box as EBR if a handle element exists,
     * otherwise they use the whole hint's bounding box as EBR.
     */
    private applyHintPositionTransform;
    /**
     * Get the EBR (Element Bounding Rectangle) for positioning.
     * Per documentation: if the hint has a handle element, use its bounding box.
     * Otherwise, use the whole hint's bounding box.
     */
    private getEBRBounds;
    /**
     * Calculate the alignment point on the RBR based on position type.
     * This is where the EBR's corresponding alignment point should be positioned.
     */
    private calculateRBRAlignmentPoint;
    /**
     * Calculate the alignment point on the EBR based on position type.
     * This is the point on the EBR that should align with the RBR alignment point.
     */
    private calculateEBRAlignmentPoint;
    /**
     * Handle spreading for solid hints.
     * @param versionTag - Version tag for tracking spreading history
     */
    private handleSpreading;
    /**
     * Apply r_h-* overrides to hint properties.
     * Overrides can target specific hints or all hints ("*").
     *
     * @param hint - Original hint design
     * @param hintId - ID of the hint being rendered
     * @param hintOverrides - Map of overrides from r_h-* features
     * @param allBaseNodes - All base nodes for displaced span resolution
     * @returns Modified hint with overrides applied
     */
    private applyHintOverrides;
    /**
     * Update settings.
     */
    updateSettings(settings: GveRenditionSettings): void;
}
