lintje 0.1.1

package/dist-elements/types/components/content/audio-player/player.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `LintjePlayerElement` — what the audio and video players share; registers no tag.
+ *
+ * Events: `lintje-time-change` (seconds; at most four a second while playing, at once after a
+ * seek or pause), `lintje-seek` (seconds: the reader moved the position, with the bar, a key or a
+ * skip), `lintje-play`, `lintje-pause`.
+ *
+ * Setting `currentTime` seeks without an event of its own, so a host that answers
+ * `lintje-time-change` by setting it cannot loop. A seek before the duration is known is kept.
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+export declare abstract class LintjePlayerElement extends LintjeElement {
+    static properties: PropertyDeclarations;
+    /** The recording's URL. Without it the controls are disabled. */
+    src: string;
+    /** The recording's name: the accessible name of the player's group. */
+    name: string;
+    /** The duration in seconds, shown before the media has loaded. */
+    duration?: number;
+    protected position: number;
+    /**
+     * The position the slider states. It follows playback only while the slider has no focus: a
+     * value that changes every second is read out every second.
+     */
+    protected heard: number;
+    protected playing: boolean;
+    protected ready: boolean;
+    protected failed: boolean;
+    protected mediaDuration: number;
+    protected speed: number;
+    private pendingSeek;
+    private readonly limit;
+    private listening;
+    protected abstract readonly mediaSelector: string;
+    /** The position in seconds. Setting it seeks; it sends no event of its own. */
+    get currentTime(): number;
+    set currentTime(seconds: number);
+    protected get media(): HTMLMediaElement | null;
+    protected get length(): number;
+    /** Moves the media to `seconds`; with `report` the host hears at once. */
+    protected seek(seconds: number, report?: boolean): void;
+    protected report(force: boolean): void;
+    protected toggle(): void;
+    /** Plays from where it stands: what "Fragment afspelen" asks after a seek. */
+    play(): void;
+    protected skip(seconds: number): void;
+    protected setSpeed(speed: number): void;
+    protected retry(): void;
+    private readonly onMetadata;
+    private readonly onTimeUpdate;
+    private readonly onSeeked;
+    private readonly onPlay;
+    private readonly onPause;
+    private readonly onError;
+    private readonly mediaEvents;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    /** Space plays or pauses wherever the focus is in the player, except on a native control. */
+    protected onGroupKeydown(event: KeyboardEvent): void;
+    protected onSliderKeydown(event: KeyboardEvent): void;
+    private seekFromPointer;
+    protected onSliderPointerDown(event: PointerEvent): void;
+    protected onSliderPointerMove(event: PointerEvent): void;
+    /** `aria-disabled` while not ready: it stays in the tab order, its press is swallowed. */
+    protected renderPlay(): TemplateResult;
+    protected renderIconButton(icon: string, label: string, onClick: () => void, options?: {
+        flip?: boolean;
+        disabled?: boolean;
+        pressed?: boolean;
+        className?: string;
+    }): TemplateResult;
+    protected sliderLabel(): string;
+    protected renderBar(): TemplateResult;
+    protected renderTime(full: boolean): TemplateResult;
+}

package/dist-elements/types/components/content/code/code.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `<lintje-code>` — a block of code or JSON, on `--font-mono`; the host pretty-prints JSON.
+ *
+ * Scrolls sideways by default because a broken line is a changed line; the block is
+ * `tabindex="0"` so the scroll is keyboard reachable (WCAG 2.1.1). `numbered` uses a CSS
+ * counter, so a copy of the block is a copy of the code. No syntax colouring.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeGridItemElement } from '../../../primitives/shared/grid-item-element.js';
+export declare class LintjeCode extends LintjeGridItemElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    text?: string;
+    /** Shown as the label top right: `json`, `sql`, `python`. */
+    language?: string;
+    numbered: boolean;
+    /** Break long lines instead of scrolling the block sideways. */
+    wrap: boolean;
+    /** The accessible name of the block. The default names the language. */
+    label?: string;
+    private get body();
+    private get name();
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-code': LintjeCode;
+    }
+}

package/dist-elements/types/components/content/document-viewer/document-viewer.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `<lintje-document-viewer>` — a document page by page: leaf, zoom and download.
+ *
+ * Shows images only: `.pages` is one URL per page, `src` a single image. The host renders a PDF
+ * to page images; no PDF library is shipped. An image is no text: give each page's text in
+ * `.texts` (same order), which a screen reader reads after the page. The file behind
+ * "Downloaden" is the accessible version, so it is a tagged, accessible PDF, not a scan.
+ *
+ * `page` (from 1) and `zoom` (50–400 in steps of 25, or `fit`) are the element's; every change
+ * is reported.
+ *
+ * Events: `lintje-page-change` (the page, from 1), `lintje-zoom-change` (a percentage or
+ * `'fit'`), `lintje-download`.
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/button/button.js';
+import '../../../primitives/skeleton/skeleton.js';
+import '../../feedback/empty-state/empty-state.js';
+export type ZoomLevel = number | 'fit';
+export declare const ZOOM_MIN = 50;
+export declare const ZOOM_MAX = 400;
+export declare const ZOOM_STEP = 25;
+/** An attribute's zoom: `fit`, or a number clamped to 50–400. */
+export declare function parseZoom(value: unknown): ZoomLevel;
+/** One zoom step: the next multiple of 25 inside 50–400; from `fit` it starts at `fitPercent`. */
+export declare function stepZoom(zoom: ZoomLevel, direction: 1 | -1, fitPercent: number): number;
+/** The figure between the zoom buttons; at `fit` the measured percentage, empty before that. */
+export declare function zoomLabel(zoom: ZoomLevel, fitPercent?: number): string;
+export declare function clampPage(page: number, count: number): number;
+export declare function pageLabel(page: number, count: number): string;
+export declare class LintjeDocumentViewer extends LintjeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    /** One image URL per page: the host renders a PDF to these. */
+    pages: string[];
+    /** The text of each page, in the order of `.pages` (or of `src`): the pages' text alternative. */
+    texts?: string[];
+    /** A single image, when there is no `.pages`. */
+    src: string;
+    /** The file name: the toolbar's title and part of the page's accessible name. */
+    name: string;
+    page: number;
+    zoom: ZoomLevel;
+    protected loaded: boolean;
+    protected failed: boolean;
+    protected naturalWidth: number;
+    protected fitPercent: number;
+    /** What a change of page or zoom says in the status region; empty until one is made. */
+    protected said: string;
+    private shown;
+    private get urls();
+    private get count();
+    private get url();
+    private goTo;
+    private setZoom;
+    private zoomBy;
+    private download;
+    private measureFit;
+    private onLoad;
+    private onError;
+    private onKeydown;
+    /** A zoomed page that can still scroll that way keeps the page keys for scrolling. */
+    private scrollsItself;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    private renderButton;
+    private renderToolbar;
+    private renderPage;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-document-viewer': LintjeDocumentViewer;
+    }
+}

package/dist-elements/types/components/content/gallery/gallery.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `<lintje-gallery>` — pictures of one thing, such as the screens of an application: one large
+ * with its caption, and under it a thumbnail of each to choose another. A single picture has no
+ * thumbnails. Which picture stands is the element's; every change is reported, and read out
+ * from a status region: "Afbeelding 2 van 4: <alt>".
+ *
+ * Events: `lintje-gallery-change` `{ index }`.
+ */
+import { nothing, type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+export interface GalleryItem {
+    src: string;
+    /** What the picture shows, for a reader who cannot see it. */
+    alt: string;
+    /** The line under the large picture. */
+    caption?: string;
+}
+export declare class LintjeGallery extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    items: GalleryItem[];
+    /** The picture that stands large, from 0. */
+    selected: number;
+    /** Names the row of thumbnails: "Schermafbeeldingen van Vertalen". */
+    label: string;
+    /** What the status region says after a choice. */
+    spoken: string;
+    /** `selected` kept inside the items, as the large picture shows it. */
+    private get shown();
+    private choose;
+    protected render(): TemplateResult | typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-gallery': LintjeGallery;
+    }
+}

package/dist-elements/types/components/content/highlight/highlight.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `<lintje-highlight>` — a marking in running text: low confidence, a glossary term, a search
+ * match, or a difference. Each kind draws the element that means it and a line of its own, so
+ * colour is never the only carrier. A difference also says what it is in hidden words, since a
+ * screen reader does not name `<del>` and `<ins>`. The host wraps the words. Events: none.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/tooltip/tooltip.js';
+export type HighlightKind = 'uncertain' | 'term' | 'match' | 'added' | 'removed';
+export declare class LintjeHighlight extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    kind: HighlightKind;
+    /** The active search match; only for `match`. */
+    current: boolean;
+    /** For a term: the glossary's explanation, in a tooltip. Makes the term a button. */
+    explanation?: string;
+    /** For a difference, what the hidden words call it ("jouw versie"); else "verwijderd" or "toegevoegd". */
+    label?: string;
+    private get isControl();
+    private get classes();
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-highlight': LintjeHighlight;
+    }
+}

package/dist-elements/types/components/content/prose/prose.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `<lintje-prose>` — a block of text on the type scale. `html` wins over `text`, which wins over
+ * the slot.
+ *
+ * The host renders the markdown and sanitises it: `html` is written into the shadow root as it
+ * stands, and no sanitiser lives here. Events: none.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeGridItemElement } from '../../../primitives/shared/grid-item-element.js';
+export type ProseTone = 'default' | 'muted';
+export declare class LintjeProse extends LintjeGridItemElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    /** Server-rendered, server-sanitised HTML. A property only. */
+    html?: string;
+    /** One paragraph. Ignored when `html` is set. */
+    text?: string;
+    /** `muted` suits a caption or a source line. */
+    tone: ProseTone;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-prose': LintjeProse;
+    }
+}

package/dist-elements/types/components/content/transcript/transcript.d.ts

@@ -0,0 +1,152 @@
+/**
+ * `<lintje-transcript>` — a recording's text in fragments, each with its speaker and timecode.
+ *
+ * `readonly` shows the text only, as a preview beside a running recording does: no editing, no
+ * speaker menu and no seeking.
+ *
+ * Every speaker takes a colour, the same as in the player's waveform: a bar along the fragment,
+ * the name beside it says who it is. `layout="chat"` draws each fragment as a message instead of
+ * a row; `tinted` lays the speaker's colour under the whole fragment; `grouped` names a speaker
+ * once over consecutive fragments, each keeping its own time. The fragment that sounds stands out
+ * with a ring. Live, `speakingId` says who speaks now and a fragment's `pending` text is still
+ * provisional.
+ *
+ * Above the fragments stands a row in the same columns: `note-label` beside `note` — the label
+ * that a model made the text, and the host's sentence about it — and under it what the host
+ * slots in `lead` (the AI work, each in its own expander).
+ *
+ * A fragment is edited from its pencil or by a double click on its text.
+ *
+ * Editing and the speakers are the host's state: the element asks, the host changes `segments`,
+ * `editingId`, `busyId` and `errors`. It plays, saves and renames nothing itself. The search
+ * property is `searchMatches`, not `matches` (that is `Element.matches()`).
+ *
+ * Events: `lintje-seek` (seconds), `lintje-segment-edit` (id), `lintje-segment-save`
+ * `{ id, text }`, `lintje-segment-cancel` (id), `lintje-segment-speaker` `{ id, speaker }` (this
+ * fragment to another speaker), `lintje-speaker-new` (id: this fragment to a speaker not named
+ * yet), `lintje-speaker-rename` (the name to change everywhere).
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/button/button.js';
+import '../../../primitives/icon-button/icon-button.js';
+import '../highlight/highlight.js';
+import '../../inputs/textarea/textarea.js';
+import '../../actions/menu-button/menu-button.js';
+import type { MenuEntry } from '../../actions/menu-button/menu-button.js';
+import { type BadgeTone } from '../../../primitives/badge/badge.js';
+export interface TranscriptSegment {
+    id: string;
+    /** When it starts, in seconds. */
+    start: number;
+    speaker: string;
+    text: string;
+    /** Character ranges `[from, to)` the recogniser was unsure of. */
+    uncertain?: [number, number][];
+    /** Words under the timecode: "Actiepunt". */
+    tags?: {
+        label: string;
+        tone?: BadgeTone;
+    }[];
+    /** Live: the tail the recogniser may still change, after `text`. */
+    pending?: string;
+}
+export interface TextPart {
+    text: string;
+    uncertain: boolean;
+}
+/** Character ranges `[from, to)` of a host's search hits, per segment id. */
+export type TranscriptMatches = Record<string, [number, number][]>;
+/** The current hit: the segment, and the index into that segment's ranges. */
+export interface TranscriptMatch {
+    id: string;
+    index: number;
+}
+/** `match` is the index of the hit the stretch is in, -1 for none. */
+export interface MarkedPart extends TextPart {
+    match: number;
+}
+export type TranscriptLayout = 'rows' | 'chat';
+/** How long a reader's own scroll keeps the transcript from following the recording. */
+export declare const FOLLOW_PAUSE = 5000;
+/**
+ * The text cut at the uncertain ranges and at the search hits. A hit keeps its index into
+ * `matches`, so the current one can be found; ranges are clamped to the text.
+ */
+export declare function markedParts(text: string, uncertain?: readonly [number, number][], matches?: readonly [number, number][]): MarkedPart[];
+export declare function shouldFollow(now: number, lastUserScroll: number): boolean;
+/** The speaker menu of one fragment: to whom it belongs, a new speaker, the name everywhere. */
+export declare function speakerMenu(speaker: string, speakers: readonly string[]): MenuEntry[];
+export declare class LintjeTranscript extends LintjeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    segments: TranscriptSegment[];
+    /**
+     * Every speaker, in the order of their colours: the menu offers them, and a filtered list keeps
+     * its colours. Without it, those in `segments`.
+     */
+    speakers?: string[] | null;
+    readonly: boolean;
+    /** Live: the segment of who speaks now. */
+    speakingId?: string | null;
+    /** `large`: for reading along on a screen in the room. */
+    size: 'regular' | 'large';
+    /** `chat`: every fragment a message under its speaker, instead of a row. */
+    layout: TranscriptLayout;
+    /** The speaker's colour under the whole fragment, not only in its bar. */
+    tinted: boolean;
+    /** A speaker's consecutive fragments under one name. */
+    grouped: boolean;
+    /** The recording's position in seconds. */
+    currentTime?: number | null;
+    /** The segment in editing; the host sets it after `lintje-segment-edit`. */
+    editingId?: string | null;
+    busyId?: string | null;
+    /** A save that failed: the message under the field, per segment id. */
+    errors: Record<string, string>;
+    searchMatches: TranscriptMatches;
+    /** The hit framed as current; scrolled into view when it changes. */
+    currentMatch?: TranscriptMatch | null;
+    protected hasNote: boolean;
+    private lastUserScroll;
+    private followed;
+    /** The segment whose field had the focus when its save began. */
+    private savedFrom;
+    private get currentIndex();
+    private segmentElement;
+    private focusInside;
+    /** The note's row shows only when the host gave it a sentence. */
+    private readonly onNoteChange;
+    private readonly onUserScroll;
+    private readonly onListKeydown;
+    private seek;
+    private edit;
+    private save;
+    private cancel;
+    private onEditorKeydown;
+    /** The menu's own `lintje-action` ends here, as the request it stands for. */
+    private onSpeakerAction;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    /**
+     * A saving field is natively disabled, which drops its focus to the page: "Opslaan", busy but
+     * focusable, holds it meanwhile, and a save that failed gives it back to the field.
+     */
+    private keepSaveFocus;
+    protected updated(changed: PropertyValues<this>): void;
+    /**
+     * Brings the fragment that sounds into view now, also when the reader scrolled away: after the
+     * reader moved the recording's position.
+     */
+    reveal(): void;
+    private follow;
+    private renderText;
+    private renderEditor;
+    private renderSpeaker;
+    private renderTime;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-transcript': LintjeTranscript;
+    }
+}

package/dist-elements/types/components/content/translator/translator.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `<lintje-translator>` — a text and its translation in one surface of two halves: the source on
+ * the left, the translation on the right, each with its language above and its actions below.
+ * The two languages flank the swap on the line between them. Below 768 px the halves stack.
+ *
+ * The source is a plain `lintje-textarea`; the host keeps `value`. The translation, the language
+ * choices and the actions are the host's, in slots: `source-language`, `target-language`,
+ * `target` (a plain `lintje-streaming-text`), `source-actions`, `target-note` (the AI label, right
+ * under the translation) and `target-actions`.
+ *
+ * `variant="documents"` keeps the language bar and the swap and puts the default slot under them
+ * at full width, for documents to translate: the upload and the queue.
+ *
+ * After the swap a status region says so, with the languages the host's choices then show
+ * ("Talen omgewisseld: Engels naar Nederlands").
+ *
+ * Events: `lintje-text-change` (the source text), `lintje-languages-swap`.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../inputs/textarea/textarea.js';
+import '../../../primitives/icon-button/icon-button.js';
+export declare class LintjeTranslator extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    value: string;
+    /** The limit the source's counter counts to. */
+    maxlength?: number;
+    placeholder: string;
+    /** The source's accessible name, and its half's. */
+    sourceLabel: string;
+    /** The translation half's accessible name. */
+    targetLabel: string;
+    /** `text` (default): the source and its translation; `documents`: the languages over the default slot. */
+    variant: 'text' | 'documents';
+    /** What the status region says after a swap. */
+    spoken: string;
+    private spokenTimer;
+    private get field();
+    private onText;
+    private clear;
+    disconnectedCallback(): void;
+    private swap;
+    private renderStatus;
+    private renderSwap;
+    private renderDocuments;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-translator': LintjeTranslator;
+    }
+}

package/dist-elements/types/components/content/video-player/video-player.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `<lintje-video-player>` — the picture of a recording, with the audio player's controls.
+ *
+ * The controls stand under the picture, never over it, also in full screen: the bar with the time
+ * on one line; play, mute, "Meer opties" and full screen on the next, at any width. The menu holds
+ * the captions (also on C), the audio description when `described-src` gives a version with one
+ * (it switches at the same moment) and the speed; a speed other than 1× stands beside the time. The
+ * controls are `aria-disabled` (in the tab order, the press swallowed) while the video loads or
+ * cannot be loaded; a failed load says so on the picture, with "Opnieuw proberen". The `<video>`
+ * has no controls of its own and never starts by itself. It does not fetch the captions. The big
+ * play button stands on the picture only before the start, and the caption shows only without
+ * it, so the two never cover each other.
+ *
+ * Events: `lintje-time-change` (seconds, at most four times a second), `lintje-play`,
+ * `lintje-pause`.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import '../../actions/menu-button/menu-button.js';
+import { LintjePlayerElement } from '../audio-player/player.js';
+export interface TimedText {
+    start: number;
+    text: string;
+}
+export declare class LintjeVideoPlayer extends LintjePlayerElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    /** The captions: the transcript's segments, or any `{ start, text }[]`. */
+    segments: TimedText[];
+    /** Whether the captions show; the reader switches it. */
+    captions: boolean;
+    /** The same video with an audio description: "Meer opties" offers it when given. */
+    describedSrc?: string;
+    /** Whether the described version plays; the reader switches it. */
+    described: boolean;
+    protected fullscreen: boolean;
+    protected muted: boolean;
+    protected readonly mediaSelector = "video";
+    private get frame();
+    private readonly onFullscreenChange;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** What the `<video>` plays: the described version when the reader chose it. */
+    private get source();
+    /** The other version goes on at the same moment, and plays on if this one played. */
+    private switchDescribed;
+    private get caption();
+    /** At the start, before anything sounds; the caption takes its place once the video moves. */
+    private get waiting();
+    private get menuItems();
+    /** Entering waits until the video has loaded; leaving always works. */
+    private toggleFullscreen;
+    /** The big button goes away once it plays: the focus moves to the play button below. */
+    private readonly onBigPlay;
+    /** The retry button goes away with the failure: the focus moves to the play button there. */
+    private readonly onRetry;
+    private onMenuAction;
+    private onKeydown;
+    private renderFailed;
+    private renderOverlay;
+    private renderStage;
+    /** As the audio player's: one name, pressed while muted. */
+    private renderMute;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-video-player': LintjeVideoPlayer;
+    }
+}

package/dist-elements/types/components/feedback/ai-label/ai-label.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `<lintje-ai-label>` — says that a model made the content below it.
+ *
+ * A neutral badge (provenance, not a verdict) and the one badge that may wrap, so a long name
+ * stays on a 390 px screen. Place it above the block, once. `checked-by` turns it into
+ * "Gecontroleerd door …", and the gear-and-brain mark into a check.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+export declare class LintjeAiLabel extends LintjeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    /** Who checked the text: "J. de Vries". */
+    checkedBy?: string;
+    /** The line behind the badge; unchecked it defaults to the advice to check the text. */
+    hint?: string;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-ai-label': LintjeAiLabel;
+    }
+}

package/dist-elements/types/components/feedback/announcement/announcement.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `<lintje-announcement>` — a status message: warning, outage, info or ok.
+ *
+ * A live region only with `live: true`; drawn empty first and filled on the next frame so screen
+ * readers announce it. `slot="action"` stands under the text, `slot="media"` beside it: an image
+ * that belongs to the message, such as a code to scan. Closed with the focus on its close button,
+ * it hands the focus to the next stop on the page (else the one before) before it goes.
+ */
+import { nothing, type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { type FrameSettings } from '../../../core/element.js';
+import { LintjeGridItemElement } from '../../../primitives/shared/grid-item-element.js';
+import '../../../primitives/tile/tile.js';
+import type { AnnouncementViewData } from '../../../types.js';
+export declare class LintjeAnnouncement extends LintjeGridItemElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    data?: AnnouncementViewData | null;
+    /** The tighter form. Below 768 px every announcement is compact. */
+    compact: boolean;
+    dismissed: string | null;
+    filled: string | null;
+    private fillFrame;
+    protected get dataSettings(): FrameSettings | undefined;
+    private get identity();
+    private get isDismissed();
+    /** Whether `node` stands in this element: in its shadow root or slotted into it. */
+    private holds;
+    /** The page's next tab stop outside the announcement, else the one before it. */
+    private neighbour;
+    private close;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    protected render(): TemplateResult | typeof nothing;
+    private block;
+    private content;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-announcement': LintjeAnnouncement;
+    }
+}

package/dist-elements/types/components/feedback/conflict-alert/conflict-alert.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `<lintje-conflict-alert>` — someone else changed the item while the reader was editing it.
+ *
+ * A compact live warning announcement above the form with three actions. It takes the focus when
+ * it appears, so the keyboard continues at its buttons. It saves nothing; the host answers the
+ * events. `lintje-conflict-compare` lets a host fetch the differences only when asked.
+ *
+ * Events: `lintje-conflict-keep-mine`, `lintje-conflict-take-theirs`, `lintje-conflict-compare`
+ * `{ open }`.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/button/button.js';
+import '../announcement/announcement.js';
+import '../../content/highlight/highlight.js';
+import type { AnnouncementViewData } from '../../../types.js';
+/** One field both versions changed, as the host formats the texts. */
+export interface ConflictChange {
+    label: string;
+    mine: string;
+    theirs: string;
+}
+export type ConflictChoice = 'mine' | 'theirs';
+export declare function conflictText(who?: string, when?: string, item?: string): AnnouncementViewData;
+export declare class LintjeConflictAlert extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    /** Who changed the item: "M. Jansen". */
+    who?: string;
+    /** When, as the host formats it: "10:40". */
+    when?: string;
+    /** What was changed, as it reads in the sentence: "deze melding". */
+    item: string;
+    /** The version being saved: that button is busy, the others disabled. */
+    busy?: ConflictChoice | '';
+    changes: ConflictChange[];
+    comparing: boolean;
+    protected firstUpdated(): void;
+    private compare;
+    private renderChanges;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-conflict-alert': LintjeConflictAlert;
+    }
+}