@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/validation/index.d.ts

@@ -1,3 +0,0 @@
-export * from './TypeRegistry';
-export * from './ValidationEngine';
-export * from './ConnectionGroupValidator';

package/src/libs/engine/src/validation/index.js

@@ -1,8 +0,0 @@
-"use strict";
-// Validation index - exports validation system components
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./TypeRegistry"), exports);
-tslib_1.__exportStar(require("./ValidationEngine"), exports);
-tslib_1.__exportStar(require("./ConnectionGroupValidator"), exports);
-//# sourceMappingURL=index.js.map

package/src/libs/renderer/src/a11y/diagram-outline.d.ts

@@ -1,93 +0,0 @@
-import { type DiagramLike } from './semantics';
-/**
- * The DIAGRAM OUTLINE — a screen-reader-navigable TEXT MIRROR of the graph.
- *
- * This is the capability no competitor ships. Mermaid is read-only pictures;
- * React Flow / GoJS / JointJS give a screen reader, at best, a bag of labelled
- * shapes with no edges (we did too, until card 0 of this wave). None of them
- * give an AT user the *topology*: where a flow starts, what each node leads to,
- * what loops back, what is unreachable.
- *
- * The outline is that topology, as a structured tree the AT virtual cursor can
- * browse with its normal list/tree keys — plus a natural-language summary read
- * on entry, so the user knows the shape of the thing before walking it.
- *
- * Pure model → outline. Rendering it to DOM is `outline-view.ts`'s job; keeping
- * the two apart is what lets us unit-test the *content* with no DOM at all.
- *
- * Wave 6 (a11y card 6).
- */
-export interface OutlineEdgeRef {
-    linkId: string;
-    targetId: string;
-    targetName: string;
-    /** The edge's own label ("yes" / "no" on a decision), if any. */
-    label?: string;
-    /** True when this edge closes a cycle — the single most useful fact. */
-    closesCycle: boolean;
-}
-export interface OutlineNode {
-    nodeId: string;
-    name: string;
-    /** Human shape name — "Decision", "Process". */
-    roleDescription: string;
-    incoming: number;
-    outgoing: number;
-    /** Where this node leads. */
-    targets: OutlineEdgeRef[];
-    /** Nested nodes (group / parent containment). */
-    children: OutlineNode[];
-    isEntryPoint: boolean;
-    isTerminal: boolean;
-    isIsolated: boolean;
-    /** Participates in at least one cycle. */
-    inCycle: boolean;
-    /** 1-based position in reading order, and the total — "node 3 of 12". */
-    index: number;
-    total: number;
-}
-export interface DiagramOutline {
-    /** Natural-language summary, read when focus enters the diagram. */
-    summary: string;
-    /** The containment forest, in reading order. */
-    roots: OutlineNode[];
-    /** Flat reading-order view — what the roving tabindex walks. */
-    flat: OutlineNode[];
-    entryPoints: string[];
-    terminals: string[];
-    isolated: string[];
-    cycles: string[][];
-    nodeCount: number;
-    edgeCount: number;
-    componentCount: number;
-    /** Every edge, as an AT-readable sentence (the edge list of the mirror). */
-    edges: {
-        linkId: string;
-        text: string;
-    }[];
-    /** Cheap change key — see `outlineSignature`. */
-    signature: string;
-}
-export declare function buildOutline(diagram: DiagramLike): DiagramOutline;
-/**
- * The NATURAL-LANGUAGE SUMMARY. What a colleague would say if you asked them
- * "what does this diagram show?" over the phone.
- *
- * "Flowchart with 8 nodes and 9 edges. It starts at Receive order. It ends at
- *  Ship order or Reject order. It contains 1 loop: Review → Amend → Review.
- *  1 node is disconnected: Legacy step."
- */
-export declare function summarise(outline: Omit<DiagramOutline, 'summary' | 'signature'>, diagram: DiagramLike): string;
-/**
- * A cheap signature of everything the outline DEPENDS on: ids, names, states,
- * containment and endpoints. Geometry is deliberately NOT in it — dragging a
- * node changes the picture but not the topology, so it must not rebuild the
- * mirror.
- *
- * This is what makes the "no thrash" guarantee real rather than aspirational:
- * the view rebuilds only when this string changes, so a quiet frame — and a
- * pure-movement frame — does ZERO outline work.
- */
-export declare function outlineSignature(diagram: DiagramLike): string;
-/** Reading-order position context: "node 3 of 12, 2 incoming, 1 outgoing". */
-export declare function positionContext(nodeId: string, diagram: DiagramLike): string;

package/src/libs/renderer/src/a11y/focus-containment.d.ts

@@ -1,90 +0,0 @@
-import type { ViewportController } from '../viewport/viewport-controller';
-import type { Rectangle } from '../types/geometry.types';
-/**
- * FOCUS CONTAINMENT — focus must never rest on geometry the user cannot see.
- *
- * This is a real WCAG failure (2.4.11 Focus Not Obscured / 2.4.7 Focus Visible)
- * and, before this wave, we failed it outright: keyboard focus walked the whole
- * graph while the camera sat still, so tabbing past the edge of the viewport
- * left the focus ring on a node that was scrolled off-screen — announced, but
- * invisible. A sighted keyboard user simply lost the cursor.
- *
- * The fix, in order of escalation:
- *
- *   1. Already fully visible (with padding) → DO NOTHING. Not panning is the
- *      most important case: a stationary camera is what makes the diagram
- *      readable, and gratuitous re-centring on every focus step is nauseating.
- *   2. Off-screen but it FITS at the current zoom → pan the minimum distance
- *      that brings it inside the padded box. Minimum, not centring: the user
- *      keeps their mental map.
- *   3. Too big to fit at the current zoom → zoom OUT via `fitToBounds`, which
- *      is the existing camera maths. We do not fork it.
- *
- * Motion honours `prefers-reduced-motion`: an animated pan becomes an instant
- * jump. All camera writes go through {@link ViewportController} — this class
- * owns policy, not geometry.
- *
- * Wave 6 (a11y card 4).
- */
-export type ContainmentAction = 'none' | 'pan' | 'zoom';
-export interface FocusContainmentOptions {
-    /** CSS-pixel margin kept between the focused element and the viewport edge. */
-    padding?: number;
-    /** Pan animation duration, ms. 0 (or reduced motion) → instant. */
-    durationMs?: number;
-    /** Override reduced-motion detection (tests). */
-    reducedMotion?: () => boolean;
-    /** Injected clock/frame source (tests). */
-    now?: () => number;
-    requestFrame?: (cb: (t: number) => void) => number;
-    cancelFrame?: (handle: number) => void;
-}
-export interface ContainmentResult {
-    action: ContainmentAction;
-    /** World-space delta applied (or to be applied, when animating). */
-    dx: number;
-    dy: number;
-    /** Zoom applied, when `action === 'zoom'`. */
-    zoom?: number;
-}
-export declare class FocusContainmentController {
-    private readonly viewport;
-    private readonly padding;
-    private readonly durationMs;
-    private readonly reducedMotion;
-    private readonly now;
-    private readonly raf;
-    private readonly caf;
-    private animation;
-    constructor(viewport: ViewportController, options?: FocusContainmentOptions);
-    /**
-     * Is `bounds` fully inside the padded visible box? The predicate the whole
-     * card turns on — and the one a test can assert directly.
-     */
-    isFullyVisible(bounds: Rectangle, padding?: number): boolean;
-    /** The visible world box, deflated by `padding` CSS pixels on every side. */
-    paddedViewBox(padding?: number): Rectangle;
-    /**
-     * Compute what would have to happen to bring `bounds` fully into view —
-     * WITHOUT touching the camera. Pure: this is what the tests assert, and what
-     * `ensureVisible` then applies.
-     */
-    plan(bounds: Rectangle, padding?: number): ContainmentResult;
-    /**
-     * Bring `bounds` fully into view. Returns what it did — `'none'` when the
-     * element was already visible, which is the common case and costs nothing.
-     */
-    ensureVisible(bounds: Rectangle, padding?: number): ContainmentResult;
-    /** Smoothly translate the camera by a world delta. */
-    private animatePan;
-    /** True while a containment pan is animating. */
-    isAnimating(): boolean;
-    /** Cancel any in-flight pan. */
-    stop(): void;
-    dispose(): void;
-}
-/** The world bounds of a routed link — its polyline, grown a little. */
-export declare function boundsOfPoints(points: {
-    x: number;
-    y: number;
-}[], pad?: number): Rectangle | null;

package/src/libs/renderer/src/a11y/focus-containment.js

@@ -1,173 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FocusContainmentController = void 0;
-exports.boundsOfPoints = boundsOfPoints;
-const platform_1 = require("../platform/platform");
-const animation_utils_1 = require("../utils/animation-utils");
-class FocusContainmentController {
-    constructor(viewport, options = {}) {
-        var _a, _b, _c, _d, _e, _f;
-        this.animation = null;
-        this.viewport = viewport;
-        this.padding = (_a = options.padding) !== null && _a !== void 0 ? _a : 48;
-        this.durationMs = (_b = options.durationMs) !== null && _b !== void 0 ? _b : 180;
-        this.reducedMotion = (_c = options.reducedMotion) !== null && _c !== void 0 ? _c : (() => (0, animation_utils_1.prefersReducedMotion)());
-        this.now = (_d = options.now) !== null && _d !== void 0 ? _d : (() => (0, platform_1.now)());
-        this.raf = (_e = options.requestFrame) !== null && _e !== void 0 ? _e : ((cb) => (0, platform_1.requestFrame)(cb));
-        this.caf = (_f = options.cancelFrame) !== null && _f !== void 0 ? _f : ((h) => (0, platform_1.cancelFrame)(h));
-    }
-    /**
-     * Is `bounds` fully inside the padded visible box? The predicate the whole
-     * card turns on — and the one a test can assert directly.
-     */
-    isFullyVisible(bounds, padding = this.padding) {
-        const inner = this.paddedViewBox(padding);
-        if (inner.width <= 0 || inner.height <= 0)
-            return false;
-        return (bounds.x >= inner.x &&
-            bounds.y >= inner.y &&
-            bounds.x + bounds.width <= inner.x + inner.width &&
-            bounds.y + bounds.height <= inner.y + inner.height);
-    }
-    /** The visible world box, deflated by `padding` CSS pixels on every side. */
-    paddedViewBox(padding = this.padding) {
-        const box = this.viewport.getViewBox();
-        const zoom = this.viewport.getZoom() || 1;
-        // Padding is specified in SCREEN pixels; the box is WORLD units.
-        const pad = padding / zoom;
-        return {
-            x: box.x + pad,
-            y: box.y + pad,
-            width: box.width - pad * 2,
-            height: box.height - pad * 2,
-        };
-    }
-    /**
-     * Compute what would have to happen to bring `bounds` fully into view —
-     * WITHOUT touching the camera. Pure: this is what the tests assert, and what
-     * `ensureVisible` then applies.
-     */
-    plan(bounds, padding = this.padding) {
-        if (!isFiniteRect(bounds))
-            return { action: 'none', dx: 0, dy: 0 };
-        const inner = this.paddedViewBox(padding);
-        // A canvas smaller than its own padding has no usable interior — treat it as
-        // "cannot contain" and fit, rather than dividing by a negative box.
-        if (inner.width <= 0 || inner.height <= 0) {
-            return { action: 'zoom', dx: 0, dy: 0, zoom: this.viewport.getZoom() };
-        }
-        // (3) Does not fit at this zoom → zoom out to fit.
-        if (bounds.width > inner.width || bounds.height > inner.height) {
-            return { action: 'zoom', dx: 0, dy: 0, zoom: this.viewport.getZoom() };
-        }
-        // (2) Minimum pan that brings it inside.
-        let dx = 0;
-        let dy = 0;
-        if (bounds.x < inner.x)
-            dx = bounds.x - inner.x;
-        else if (bounds.x + bounds.width > inner.x + inner.width) {
-            dx = bounds.x + bounds.width - (inner.x + inner.width);
-        }
-        if (bounds.y < inner.y)
-            dy = bounds.y - inner.y;
-        else if (bounds.y + bounds.height > inner.y + inner.height) {
-            dy = bounds.y + bounds.height - (inner.y + inner.height);
-        }
-        // (1) Already visible.
-        if (dx === 0 && dy === 0)
-            return { action: 'none', dx: 0, dy: 0 };
-        return { action: 'pan', dx, dy };
-    }
-    /**
-     * Bring `bounds` fully into view. Returns what it did — `'none'` when the
-     * element was already visible, which is the common case and costs nothing.
-     */
-    ensureVisible(bounds, padding = this.padding) {
-        const plan = this.plan(bounds, padding);
-        this.stop();
-        if (plan.action === 'none')
-            return plan;
-        if (plan.action === 'zoom') {
-            // Reuse the camera's own fit maths — do not reimplement it here.
-            const zoom = this.viewport.fitToBounds(bounds, padding);
-            return { action: 'zoom', dx: 0, dy: 0, zoom };
-        }
-        if (this.durationMs <= 0 || this.reducedMotion()) {
-            this.viewport.pan(plan.dx, plan.dy);
-            return plan;
-        }
-        this.animatePan(plan.dx, plan.dy);
-        return plan;
-    }
-    /** Smoothly translate the camera by a world delta. */
-    animatePan(dx, dy) {
-        const start = this.now();
-        let applied = 0;
-        const step = () => {
-            const elapsed = this.now() - start;
-            const t = Math.min(1, elapsed / this.durationMs);
-            const eased = easeOutCubic(t);
-            // Apply the DELTA since the last frame, so we never fight another pan
-            // that lands mid-animation — the camera is authoritative, not our copy.
-            const target = eased;
-            const delta = target - applied;
-            applied = target;
-            this.viewport.pan(dx * delta, dy * delta);
-            if (t < 1) {
-                this.animation = this.raf(step);
-            }
-            else {
-                this.animation = null;
-            }
-        };
-        this.animation = this.raf(step);
-    }
-    /** True while a containment pan is animating. */
-    isAnimating() {
-        return this.animation !== null;
-    }
-    /** Cancel any in-flight pan. */
-    stop() {
-        if (this.animation !== null) {
-            this.caf(this.animation);
-            this.animation = null;
-        }
-    }
-    dispose() {
-        this.stop();
-    }
-}
-exports.FocusContainmentController = FocusContainmentController;
-function easeOutCubic(t) {
-    return 1 - Math.pow(1 - t, 3);
-}
-function isFiniteRect(r) {
-    return (Number.isFinite(r.x) && Number.isFinite(r.y) &&
-        Number.isFinite(r.width) && Number.isFinite(r.height));
-}
-/** The world bounds of a routed link — its polyline, grown a little. */
-function boundsOfPoints(points, pad = 8) {
-    if (!points || points.length === 0)
-        return null;
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (const p of points) {
-        if (!Number.isFinite(p.x) || !Number.isFinite(p.y))
-            continue;
-        minX = Math.min(minX, p.x);
-        minY = Math.min(minY, p.y);
-        maxX = Math.max(maxX, p.x);
-        maxY = Math.max(maxY, p.y);
-    }
-    if (!Number.isFinite(minX) || !Number.isFinite(minY))
-        return null;
-    return {
-        x: minX - pad,
-        y: minY - pad,
-        width: maxX - minX + pad * 2,
-        height: maxY - minY + pad * 2,
-    };
-}
-//# sourceMappingURL=focus-containment.js.map

package/src/libs/renderer/src/a11y/graph-topology.d.ts

@@ -1,70 +0,0 @@
-import type { NodeModel, LinkModel } from '@grafloria/engine';
-import { type DiagramLike } from './semantics';
-/**
- * Graph TOPOLOGY — the structural facts an assistive-technology user cannot
- * see: which nodes start the flow, which end it, what cycles back, what is
- * unreachable.
- *
- * This is the analysis engine behind two cards:
- *   - follow-edge keyboard traversal (card 2) — walking the real graph, not
- *     the geometry;
- *   - the navigable outline + natural-language summary (card 6).
- *
- * Pure, framework-free, model-in / facts-out. No DOM, no rendering.
- *
- * Wave 6 (a11y).
- */
-export interface Incidence {
-    /** The link. */
-    link: LinkModel;
-    /** The node at the OTHER end of it. */
-    otherId: string;
-    /** Are we the source (outgoing) or the target (incoming)? */
-    direction: 'outgoing' | 'incoming';
-}
-export interface Adjacency {
-    /** nodeId → edges leaving it. */
-    outgoing: Map<string, Incidence[]>;
-    /** nodeId → edges arriving at it. */
-    incoming: Map<string, Incidence[]>;
-}
-export interface Topology {
-    adjacency: Adjacency;
-    /** Nodes with no incoming edges — where a reader should start. */
-    entryPoints: NodeModel[];
-    /** Nodes with no outgoing edges — where flows terminate. */
-    terminals: NodeModel[];
-    /** Nodes with neither incoming nor outgoing edges. */
-    isolated: NodeModel[];
-    /** Each cycle as the ordered node ids around it. */
-    cycles: string[][];
-    /** Connected components (undirected), as node-id lists. */
-    components: string[][];
-    /** Nodes in reading order (top-to-bottom, then left-to-right). */
-    ordered: NodeModel[];
-}
-/** Reading order: the order a sighted user's eye takes. Focus order matches it. */
-export declare function readingOrder(nodes: NodeModel[]): NodeModel[];
-export declare function buildAdjacency(diagram: DiagramLike): Adjacency;
-/**
- * Every cycle reachable in the directed graph, found by DFS with a colour mark.
- * Reported once each, normalised to start at its smallest node id so the same
- * cycle is never announced twice under two rotations.
- */
-export declare function findCycles(diagram: DiagramLike, adjacency: Adjacency): string[][];
-/** Connected components, treating edges as undirected. */
-export declare function findComponents(diagram: DiagramLike, adjacency: Adjacency): string[][];
-export declare function analyseTopology(diagram: DiagramLike): Topology;
-/**
- * The edges incident on a node, ordered for keyboard traversal: outgoing first
- * (the direction a reader follows a flow), then incoming, each in the reading
- * order of the node at the far end — so pressing the same key twice always
- * walks the same way.
- */
-export declare function incidentEdges(nodeId: string, diagram: DiagramLike, adjacency?: Adjacency): Incidence[];
-/** Group/parent containment: parentId → child nodes. */
-export declare function childrenByParent(diagram: DiagramLike): Map<string, NodeModel[]>;
-/** Nodes with no parent — the roots of the containment tree. */
-export declare function rootNodes(diagram: DiagramLike): NodeModel[];
-/** Debug/summary helper: name a node id. */
-export declare function nameOf(id: string, diagram: DiagramLike): string;

package/src/libs/renderer/src/a11y/index.d.ts

@@ -1,26 +0,0 @@
-/**
- * The ACCESSIBILITY layer (wave 6).
- *
- * Framework-free, like the rest of `libs/renderer`. The Angular canvas is a
- * thin host: it constructs these controllers, hands them a container element
- * and the engine, and forwards key events. All the policy lives here.
- *
- *  - `semantics`          — roles, roledescriptions and accessible names. Pure
- *                           functions the RENDERER calls while building the
- *                           VNode tree, so the semantics survive SSR + export.
- *  - `graph-topology`     — entry points, terminals, cycles, components,
- *                           incident-edge ordering. The structural facts.
- *  - `diagram-outline`    — the outline model + natural-language summary.
- *  - `outline-view`       — the hidden, AT-navigable DOM text mirror.
- *  - `live-region`        — the managed, de-duplicated aria-live region.
- *  - `focus-containment`  — focus never rests on off-screen geometry.
- *  - `reduced-motion`     — the reduced-motion stylesheet, and the code that
- *                           actually INJECTS it (it used to be a dead file).
- */
-export * from './semantics';
-export * from './graph-topology';
-export * from './diagram-outline';
-export * from './outline-view';
-export * from './live-region';
-export * from './focus-containment';
-export * from './reduced-motion';

package/src/libs/renderer/src/a11y/index.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * The ACCESSIBILITY layer (wave 6).
- *
- * Framework-free, like the rest of `libs/renderer`. The Angular canvas is a
- * thin host: it constructs these controllers, hands them a container element
- * and the engine, and forwards key events. All the policy lives here.
- *
- *  - `semantics`          — roles, roledescriptions and accessible names. Pure
- *                           functions the RENDERER calls while building the
- *                           VNode tree, so the semantics survive SSR + export.
- *  - `graph-topology`     — entry points, terminals, cycles, components,
- *                           incident-edge ordering. The structural facts.
- *  - `diagram-outline`    — the outline model + natural-language summary.
- *  - `outline-view`       — the hidden, AT-navigable DOM text mirror.
- *  - `live-region`        — the managed, de-duplicated aria-live region.
- *  - `focus-containment`  — focus never rests on off-screen geometry.
- *  - `reduced-motion`     — the reduced-motion stylesheet, and the code that
- *                           actually INJECTS it (it used to be a dead file).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./semantics"), exports);
-tslib_1.__exportStar(require("./graph-topology"), exports);
-tslib_1.__exportStar(require("./diagram-outline"), exports);
-tslib_1.__exportStar(require("./outline-view"), exports);
-tslib_1.__exportStar(require("./live-region"), exports);
-tslib_1.__exportStar(require("./focus-containment"), exports);
-tslib_1.__exportStar(require("./reduced-motion"), exports);
-//# sourceMappingURL=index.js.map

package/src/libs/renderer/src/a11y/live-region.d.ts

@@ -1,83 +0,0 @@
-/**
- * The managed `aria-live` REGION — the canvas's voice.
- *
- * Two live regions, not one: an AT will not reliably re-announce a node whose
- * politeness changed, and mixing an error into the polite queue means it waits
- * behind whatever selection chatter is already in flight. So:
- *
- *   - `polite`    — selection, movement, focus, connect/disconnect;
- *   - `assertive` — validation failures and errors, which interrupt.
- *
- * DE-DUPLICATION is the whole design problem. A naive live region wired to a
- * render loop says "Process node, 2 connections" sixty times a second and is
- * worse than useless — the user turns it off. Three defences, all here:
- *
- *   1. IDENTICAL-MESSAGE SUPPRESSION. The same text in the same channel is
- *      dropped, unless `force` is set (a repeated action the user *did* repeat
- *      — nudging twice — is legitimately worth re-announcing).
- *   2. COALESCING. Announcements inside a short window replace, rather than
- *      queue behind, the previous one. Holding an arrow key produces the FINAL
- *      position, not fifty intermediate ones.
- *   3. MODEL-CHANGE DRIVEN. The controller is called on model change, never
- *      from the render loop. `getSpeakCount()` lets a test prove a quiet frame
- *      speaks zero times.
- *
- * Framework-free: takes a container, owns two divs, no Angular anywhere.
- *
- * Wave 6 (a11y card 5).
- */
-export type Politeness = 'polite' | 'assertive';
-export interface LiveRegionOptions {
-    /**
-     * Announcements arriving within this many ms of the previous one REPLACE it
-     * rather than following it. 0 disables coalescing (tests use this).
-     */
-    coalesceMs?: number;
-    /** Injected clock, so tests need no timers. */
-    now?: () => number;
-    /** Injected scheduler, so tests need no real setTimeout. */
-    schedule?: (fn: () => void, ms: number) => unknown;
-    cancel?: (handle: unknown) => void;
-}
-export declare class LiveRegionController {
-    private readonly politeEl;
-    private readonly assertiveEl;
-    private readonly coalesceMs;
-    private readonly now;
-    private readonly schedule;
-    private readonly cancel;
-    private lastMessage;
-    /**
-     * When the last message was spoken. `-Infinity`, NOT 0 — with 0, the very
-     * first announcement of the session looks like it arrived inside the coalesce
-     * window of a previous announcement that never happened, so it gets deferred
-     * instead of spoken. (An injected clock starting at 0 makes this obvious; a
-     * `Date.now()` clock hides it, which is exactly why the tests inject one.)
-     */
-    private lastAt;
-    private pending;
-    private timer;
-    private speakCount;
-    constructor(container: HTMLElement, options?: LiveRegionOptions);
-    private makeRegion;
-    /** The live elements, for tests and for hosts that relocate them. */
-    getElement(politeness: Politeness): HTMLElement;
-    /** What the region currently says. */
-    getMessage(politeness: Politeness): string;
-    /** How many times we have actually written to the DOM. The thrash proof. */
-    getSpeakCount(): number;
-    /**
-     * Announce. Returns true if the message will be spoken, false if it was
-     * suppressed as a duplicate.
-     */
-    announce(message: string, politeness?: Politeness, force?: boolean): boolean;
-    /** Errors and validation failures. Always assertive, never coalesced. */
-    announceError(message: string): boolean;
-    /** Speak any coalesced message immediately. */
-    flushPending(): void;
-    private speak;
-    /** Clear both regions (e.g. on blur) without announcing anything. */
-    clear(): void;
-    private flushPendingSilently;
-    dispose(): void;
-}