@grafloria/element 0.3.18 → 0.3.20

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

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

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

@@ -0,0 +1,8 @@
+"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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,173 @@
+"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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,30 @@
+"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

@@ -0,0 +1,83 @@
+/**
+ * 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;
+}