import type { DataItem } from "../../core/render/Component";
import type { ColorSet } from "../../core/util/ColorSet";
import type { Percent } from "../../core/util/Percent";
import type { IPoint } from "../../core/util/IPoint";
import type { Time } from "../../core/util/Animation";
import { Series, ISeriesSettings, ISeriesDataItem, ISeriesPrivate } from "../../core/render/Series";
import { Label } from "../../core/render/Label";
import { Container } from "../../core/render/Container";
import { Graphics } from "../../core/render/Graphics";
import { ListTemplate } from "../../core/util/List";
import type { Color } from "../../core/util/Color";
export interface IWordCloudDataItem extends ISeriesDataItem {
    /**
     * The word.
     */
    category: string;
    /**
     * The label that shows the word.
     */
    label: Label;
    /**
     * The word's color.
     */
    fill: Color;
    /**
     * @ignore
     */
    set: number;
    /**
     * @ignore
     */
    angle: number;
    /**
     * @ignore
     */
    fontSize: number;
}
export interface IWordCloudSettings extends ISeriesSettings {
    /**
     * Duration, in milliseconds, of words moving to their new places when the
     * cloud is laid out again, as when the chart resizes.
     */
    animationDuration?: number;
    /**
     * Easing of words moving to their new places.
     *
     * @see {@link https://www.amcharts.com/docs/v5/concepts/animations/#Easing_functions} for more info
     * @default am5.ease.out(am5.ease.cubic)
     */
    animationEasing?: (t: Time) => Time;
    /**
     * Shrinks all words until every one of them fits. When off, words that
     * don't fit are left out.
     *
     * @default true
     */
    autoFit?: boolean;
    /**
     * Layout progress, from `0` to `1`. The layout runs in one pass, so this
     * turns `1` each time it finishes: watch it to know when words are placed.
     *
     * @readonly
     */
    progress?: number;
    /**
     * Colors for words with no `fill` in data, one after another.
     */
    colors?: ColorSet;
    /**
     * Field in `data` that holds the words.
     *
     * @default "category"
     */
    categoryField?: string;
    /**
     * Field in `data` that holds a word's color.
     *
     * @default "fill"
     */
    fillField?: string;
    /**
     * Text to make the cloud from: each word's value is the number of times it
     * appears. Replaces `data`.
     */
    text?: string;
    /**
     * Font size of the words with the lowest value: in pixels, or a share of
     * the smaller of the cloud's width and height.
     *
     * @default am5.percent(2)
     */
    minFontSize?: number | Percent;
    /**
     * Font size of the words with the highest value: in pixels, or a share of
     * the smaller of the cloud's width and height.
     *
     * @default am5.percent(15)
     */
    maxFontSize?: number | Percent;
    /**
     * Fewest times a word must appear in `text` to be shown.
     */
    minValue?: number;
    /**
     * Most words to take from `text`, most frequent first. Doesn't limit
     * `data`.
     */
    maxCount?: number;
    /**
     * Words of `text` to leave out. Case-sensitive.
     */
    excludeWords?: Array<string>;
    /**
     * How randomly words are placed, from `0` (from the middle outwards, in
     * order of value) to `1`.
     *
     * @default 0
     */
    randomness?: number;
    /**
     * Fewest characters a word of `text` must have to be shown.
     *
     * @default 1
     */
    minWordLength?: number;
    /**
     * Angles, in degrees, that words can be rotated to.
     *
     * @default [0, -90]
     */
    angles?: number[];
    /**
     * Gives each word a random angle from `angles`, so the cloud differs on
     * every layout. When `false`, words take `angles` in turn, which with
     * `randomness: 0` makes the layout the same every time.
     *
     * @since 5.20.1
     * @default true
     */
    randomizeAngles?: boolean;
    /**
     * Lets small words tuck into the gaps between a bigger word's letters, so
     * the cloud packs tightly, though the words' boxes overlap. Set to `false`
     * to keep boxes apart, as for labels with an opaque `background`.
     *
     * @since 5.20.1
     * @default true
     */
    allowNesting?: boolean;
    /**
     * Spacing of the spiral of points that words are tried at. Smaller packs
     * words more tightly, but takes longer.
     *
     * @default 15
     */
    step?: number;
    /**
     * Experimental: an SVG path for the words to fill, scaled to fit the
     * cloud.
     *
     * The fit is approximate. Simple, bold shapes work best; tune
     * `shapeTolerance`, `maskByShape`, `angles`, `minFontSize` and
     * `maxFontSize` for a better fill.
     *
     * @since 5.20.1
     */
    svgPath?: string;
    /**
     * How many more pixels a word may reach past the `svgPath` outline, on top
     * of the bit each word overhangs by itself in proportion to its size. A
     * negative value keeps words further inside.
     *
     * Affects placement only, not the drawn `shape`.
     *
     * @since 5.20.1
     * @default 0
     */
    shapeTolerance?: number;
    /**
     * Clips the words to the `svgPath` shape, cutting off letters that reach
     * past its edge.
     *
     * @since 5.20.1
     * @default false
     */
    maskByShape?: boolean;
}
export interface IWordCloudPrivate extends ISeriesPrivate {
    /**
     * The factor `autoFit` scaled font sizes by to fit all words: `1` if it
     * didn't need to.
     */
    adjustedFontSize: number;
}
/**
 * A bit-packed glyph mask of a single word (32 pixels per int), used by the
 * layout for in-memory collision detection.
 *
 * @ignore
 */
interface IWordSprite {
    bits: Int32Array;
    stride: number;
    bw: number;
    bh: number;
}
/**
 * A computed placement of a single word. No `point` means the word could not
 * be placed (label gets hidden).
 *
 * @ignore
 */
interface IWordPlacement {
    dataItem: DataItem<IWordCloudDataItem>;
    point?: IPoint;
    angle: number;
    fontSize: number;
}
/**
 * A word cloud: words sized by their values, from `data` or counted in
 * `text`.
 *
 * @see {@link https://www.amcharts.com/docs/v5/charts/word-cloud/} for more info
 * @important
 */
export declare class WordCloud extends Series {
    static className: string;
    static classNames: Array<string>;
    _settings: IWordCloudSettings;
    _privateSettings: IWordCloudPrivate;
    _dataItemSettings: IWordCloudDataItem;
    /**
     * Draws the `svgPath` shape behind the words, while it is set: a faint
     * silhouette by default. Style it with `series.shape.setAll({ ... })`; its
     * geometry and visibility are the series'.
     *
     * @since 5.20.1
     */
    readonly shape: Graphics;
    protected _pointSets: Array<Array<IPoint>>;
    protected _sets: number;
    protected _board: Int32Array;
    protected _boardW: number;
    protected _boardH: number;
    protected _boardStride: number;
    protected _scratchCanvas?: HTMLCanvasElement;
    protected _scratchContext?: CanvasRenderingContext2D;
    protected _shapeMask?: Int32Array;
    protected _shapeMaskKey?: string;
    protected _shapeCandidates?: Array<IPoint>;
    protected _labelsContainer: Container;
    protected _maskApplied: boolean;
    protected _shapeScale: number;
    protected _shapeTx: number;
    protected _shapeTy: number;
    protected _svgPathWarned: boolean;
    protected _afterNew(): void;
    /**
     * Labels of all words. Configure them through `labels.template`.
     */
    readonly labels: ListTemplate<Label>;
    /**
     * @ignore
     */
    makeLabel(dataItem: DataItem<this["_dataItemSettings"]>): Label;
    protected _makeLabels(): ListTemplate<Label>;
    protected processDataItem(dataItem: DataItem<this["_dataItemSettings"]>): void;
    _prepareChildren(): void;
    _updateChildren(): void;
    /**
     * Measures, rasterizes and places all words in one synchronous pass.
     * Occupancy is a bit-packed in-memory board tested with bitwise AND — no
     * canvas readback and no per-frame word processing.
     */
    protected _layoutAll(): void;
    /**
     * Runs one full placement pass with all font sizes scaled by `shrink`.
     * Returns the computed placements, or `undefined` if a word did not fit
     * and `autoFit` wants a retry at a smaller scale.
     */
    protected _layoutAttempt(shrink: number): Array<IWordPlacement> | undefined;
    /**
     * Builds (or reuses) the `svgPath` shape mask for the current plot size.
     * The mask marks the fitted shape's EXTERIOR, tested against an eroded word
     * box so words stay (mostly) inside the shape. Placement is driven by the
     * distance-ranked `_shapeCandidates` (thickest interior first).
     */
    protected _prepareShapeMask(): void;
    /**
     * Shows or hides the `shape` silhouette and applies (or removes) the
     * `maskByShape` clip on the labels container, based on whether a shape is
     * currently active. Must run on EVERY `_prepareShapeMask` exit — otherwise a
     * stale clip from a previous shape would keep the labels cut off after the
     * shape is removed or its path becomes invalid.
     */
    protected _updateShapeVisibility(): void;
    /**
     * Builds a FRESH clip-mask [[Graphics]] from the fitted-shape geometry and
     * applies it to the labels container. Rebuilt on every apply because removing
     * a mask disposes it (see [[Container]]), so a single reused instance would
     * be dead after the first toggle-off.
     */
    protected _applyMaskGraphics(): void;
    /**
     * Builds candidate placement points for a shape, ordered by distance to the
     * shape's edge (thickest interior first). A two-pass chamfer distance
     * transform measures how much room each interior pixel has; placing words
     * biggest-first into the roomiest free spots fills the core first and lets
     * progressively smaller words flow out to the edges — filling the whole
     * silhouette instead of just an inscribed ellipse.
     */
    protected _buildShapeCandidates(boardW: number, boardH: number, data: Uint8ClampedArray, resolution: number): Array<IPoint>;
    /**
     * Finds the bounding box of an SVG path (in path units) by rasterizing it
     * onto the scratch canvas at decreasing probe scales until it fits, then
     * scanning the ink bounds. Canvas-based, so it works without attaching
     * any SVG element to the document.
     */
    protected _svgPathBBox(path: Path2D): {
        left: number;
        top: number;
        width: number;
        height: number;
    } | undefined;
    /**
     * Logs a one-time console warning about an unusable `svgPath` (invalid or
     * degenerate). Warns once per series to avoid flooding the console.
     */
    protected _warnSvgPath(message: string): void;
    /**
     * Builds the CSS font shorthand used to measure and rasterize a word's
     * collision mask, mirroring the renderer's `CanvasText._getFontStyle` (same
     * part order, same fallbacks) so the scratch-canvas raster lines up with the
     * drawn glyph. The weight is forced to `900` so the mask is fatter than the
     * displayed label — that extra thickness is what keeps natural spacing
     * between words (the label itself is drawn with its own weight).
     */
    protected _wordFontStyle(label: Label, fontSize: number): string;
    protected _makeScratch(): CanvasRenderingContext2D;
    /**
     * Vertical advance between lines for a label, honoring its `lineHeight`
     * setting (the theme default is 100%, i.e. one font size per line). Used to
     * stack multi-line categories (`\n`) the way the label renders them.
     */
    protected _lineStep(label: Label, fontSize: number): number;
    /**
     * Measures a word synchronously on the scratch canvas. Categories may span
     * several lines (`\n`); the width is the widest line and the height stacks
     * the lines by `lineStep`, matching the label's rendered footprint.
     */
    protected _measureWord(text: string, font: string, fontSize: number, lineStep: number): {
        width: number;
        height: number;
    };
    /**
     * Rasterizes a word (at its final font and rotation) on the scratch canvas
     * and packs the alpha channel into a bit mask.
     */
    protected _rasterizeWord(text: string, font: string, lw: number, lh: number, angle: number): IWordSprite;
    /**
     * Rasterizes a SOLID rectangle of the given (padded) dimensions at the
     * word's angle, and packs it into a bit mask. Used as the collision
     * footprint: at 0/90 degrees it equals the axis-aligned box, while for
     * diagonal words it hugs the real footprint so neighbors can pack into
     * the empty corners of the axis-aligned bounding box.
     */
    protected _rasterizeBox(lw: number, lh: number, angle: number): IWordSprite;
    /**
     * Packs the alpha channel of the scratch canvas' top-left `bw x bh`
     * region into a bit mask (32 pixels per int, MSB first).
     */
    protected _packScratch(bw: number, bh: number): IWordSprite;
    /**
     * Tests a collision mask against the occupancy board at device
     * coordinates `(px, py)` (top-left corner). Bitwise AND, exact to the
     * pixel. The glyph-shaped nesting comes from the board containing only
     * glyph ink; the mask itself is the word's solid oriented (padded) box.
     */
    protected _collidesAt(sprite: IWordSprite, px: number, py: number, board?: Int32Array): boolean;
    /**
     * Stamps a sprite into the occupancy board (bitwise OR) at device
     * coordinates `(px, py)` (top-left corner).
     */
    protected _stampSprite(sprite: IWordSprite, px: number, py: number): void;
    /**
* @ignore
*/
    disposeDataItem(dataItem: DataItem<this["_dataItemSettings"]>): void;
    /**
* Extracts words and number of their appearances from a text.
*
* @ignore
* @param  input  Source text
*/
    protected _getWords(input?: string): Array<{
        category: string;
        value: number;
    }>;
    /**
* Checks if word is capitalized (starts with an uppercase) or not.
*
* @ignore
* @param   word  Word
* @return        Capitalized?
*/
    isCapitalized(word: string): boolean;
}
export {};
//# sourceMappingURL=WordCloud.d.ts.map