import { default as default_2 } from 'react';
import { RefObject } from 'react';

/**
 * Apply the interactive bold-lock effect to an element.
 * Adds mouseenter/mouseleave listeners and returns a cleanup function.
 */
export declare function applyBoldLock(element: HTMLElement, options: BoldLockOptions): () => void;

/**
 * Apply static bold-shift compensation to an element.
 * Pre-calculates the letter-spacing needed so that CSS :hover { font-weight: bold }
 * does not shift surrounding content. Injects a scoped <style> rule.
 */
export declare function applyBoldShift(element: HTMLElement, options?: BoldShiftOptions): void;

/** Configuration for a single additional variable font axis driven on hover */
export declare interface AxisConfig {
    /**
     * Axis value at rest.
     * Defaults to the element's current computed value for that axis when provided by the
     * font's `font-variation-settings`. If the axis is not present in the computed FVS,
     * falls back to `0` — which is incorrect for axes that have a non-zero default (e.g.
     * `wdth` is typically 100, `opsz` tracks font-size). Provide an explicit `normal`
     * value for any axis whose font-default is not `0`.
     */
    normal?: number;
    /** Axis value on hover */
    hover: number;
}

/** CSS class names injected by bold-lock — use these to target generated markup */
export declare const BOLD_LOCK_CLASSES: {
    readonly probe: "wh-probe";
    readonly word: "wh-word";
    readonly line: "wh-line";
};

/** Options for the interactive bold-lock mode (mouseenter/mouseleave) */
export declare interface BoldLockOptions {
    /** wght axis value at rest — defaults to computed font-weight */
    normalWeight?: number;
    /** wght axis value on hover — defaults to 700 */
    hoverWeight?: number;
    /** Transition duration in milliseconds — defaults to 150 */
    transitionDuration?: number;
    /**
     * Interaction mode. Default: 'element'
     *
     * - **'element'** — the whole element bolds together on mouseenter/mouseleave.
     * - **'word'** — each word is an independent hover target.
     * - **'proximity'** — weight increases continuously per line based on cursor
     *   distance. Lines nearest the cursor are heaviest; weight fades with distance.
     *   Width compensation is pre-calculated per line at mount time and scaled
     *   proportionally to the weight change.
     */
    mode?: 'element' | 'word' | 'proximity';
    /**
     * Distance in px from a line's center over which weight fades from hoverWeight
     * to normalWeight. Only used in 'proximity' mode. Default: 120
     */
    proximityThreshold?: number;
    /**
     * Re-measure and reapply letter-spacing compensation whenever the element's
     * size changes (e.g. when responsive clamp() typography alters font-size at a
     * new viewport width). Uses a ResizeObserver internally. Default: true
     */
    resizeObserver?: boolean;
    /**
     * Additional variable font axes to drive on hover, beyond wght.
     * Each key is an OpenType axis tag (e.g. 'slnt', 'wdth', 'ital').
     * Applied on top of the element's existing fontVariationSettings.
     *
     * Letter-spacing compensation is only calculated for the wght axis.
     * Axes that change advance widths (e.g. wdth) will cause slight line-length
     * changes — use small deltas to keep the effect imperceptible.
     *
     * In proximity mode each axis is interpolated by cursor-distance strength,
     * the same way wght is.
     *
     * @example
     * // Lean forward and condense slightly on hover
     * axes: { slnt: { hover: -12 }, wdth: { normal: 100, hover: 95 } }
     */
    axes?: Record<string, AxisConfig>;
    /**
     * Fake a slant using CSS transform: skewX() for fonts without a slnt variable axis.
     * Does not affect advance widths. In proximity mode the skew is scaled
     * proportionally to cursor distance, giving each line its own lean.
     *
     * Saves and restores the element's original transform on cleanup.
     *
     * @example
     * falseSlant: { hoverDeg: -8 }             // lean forward 8° on hover
     * falseSlant: { hoverDeg: 8, normalDeg: 0 } // lean back on hover
     */
    falseSlant?: {
        /** skewX degrees on hover. Negative = forward lean (italic direction). */
        hoverDeg: number;
        /** skewX degrees at rest. Defaults to 0 (upright). */
        normalDeg?: number;
    };
}

/**
 * Drop-in component that applies the bold-lock effect to its children.
 * The forwarded ref is merged with the internal hook ref so both point
 * to the root DOM element.
 */
export declare const BoldLockText: default_2.ForwardRefExoticComponent<BoldLockTextProps & default_2.RefAttributes<HTMLElement>>;

declare interface BoldLockTextProps extends BoldLockOptions {
    children: default_2.ReactNode;
    className?: string;
    style?: default_2.CSSProperties;
    as?: default_2.ElementType;
}

/** Options for the static bold-shift mode (CSS :hover { font-weight: bold }) */
export declare interface BoldShiftOptions {
    /** wght axis value at rest — defaults to 400 */
    normalWeight?: number;
    /** wght axis value when bold — defaults to 700 */
    boldWeight?: number;
}

/**
 * Calculate the compensating letter-spacing (in px) needed to prevent width shift
 * when the element's wght axis moves from normalWeight to boldWeight.
 * Always returns a non-positive number (zero for single-character elements).
 * An optional shared canvas can be passed to avoid repeated allocation at call sites
 * that measure many elements (e.g. word mode with one canvas per apply call).
 */
export declare function calcCompensation(el: HTMLElement, normalWeight: number, boldWeight: number, sharedCanvas?: HTMLCanvasElement): number;

/**
 * Strip any prior bold-lock markup from an element and return clean innerHTML.
 * Removes spans injected by applyBoldLock (word and proximity modes use class-based
 * spans; legacy callers may have used data-bold-lock attributes). Safe to call
 * multiple times — idempotent.
 */
export declare function getCleanHTML(el: HTMLElement): string;

/**
 * Parse an element's computed fontVariationSettings into a key/value map.
 * Returns an empty object when the value is 'normal' or absent.
 */
export declare function getFontVariationSettings(el: HTMLElement): Record<string, number>;

/**
 * Remove bold-lock markup and restore original HTML.
 * Also disconnects any ResizeObserver attached by applyBoldLock.
 *
 * @deprecated Prefer calling the cleanup closure returned by `applyBoldLock` directly.
 * This function exists for backwards compatibility with callers that stored `originalHTML`
 * separately. New code should use: `const cleanup = applyBoldLock(el, opts); cleanup()`.
 */
export declare function removeBoldLock(element: HTMLElement, originalHTML: string): void;

/**
 * Remove the bold-shift compensation injected by applyBoldShift.
 * Finds the scoped <style> element by the element's data-bold-shift ID, removes it,
 * then strips the data-bold-shift and data-bold-shift-compensation attributes.
 * Safe to call on elements that were never passed to applyBoldShift — no-op in that case.
 */
export declare function removeBoldShift(element: HTMLElement): void;

/**
 * React hook that applies the bold-lock effect to a ref'd element.
 * Attaches mouseenter/mouseleave listeners and cleans them up on unmount
 * or when key options change (normalWeight, hoverWeight, transitionDuration, mode,
 * axes, falseSlant, proximityThreshold, resizeObserver).
 *
 * Also re-applies after fonts are ready so Canvas compensation is measured against
 * the loaded variable font rather than the fallback.
 */
export declare function useBoldLock(options: BoldLockOptions): RefObject<HTMLElement | null>;

export { }