lintje 0.1.1

package/dist-elements/types/components/feedback/empty-state/empty-state.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `<lintje-empty-state>` — the empty state on its own, outside a tile.
+ *
+ * Not an error: a failure is the tile's error state or an inline alert. It brings no action or
+ * words of its own; the host chooses them and slots the action. `compact` is one muted line
+ * with a link button after it. `status` puts it in a `role="status"` for when it appears after
+ * an action: drawn empty first and filled on the next frame, since a region that arrives with
+ * its words is not announced.
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+export type HeadingLevel = 2 | 3 | 4 | 5 | 6;
+export declare class LintjeEmptyState extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    /** Not drawn when `compact`. */
+    heading?: string;
+    /** The one sentence below the heading, or the whole line when `compact`. */
+    text?: string;
+    /** An icon file name. Not drawn when `compact`. */
+    icon?: string;
+    compact: boolean;
+    level: HeadingLevel;
+    /** Announces the state: it appeared after an action. */
+    status: boolean;
+    slotted: boolean;
+    protected filled: boolean;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private onSlotChange;
+    private renderHeading;
+    protected render(): TemplateResult;
+    private content;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-empty-state': LintjeEmptyState;
+    }
+}

package/dist-elements/types/components/feedback/job-list/job-list.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `<lintje-job-list>` — the queue of long tasks: what runs, what is done and what went wrong. Its
+ * rows are the work list's rows (`lintje-list`): the state as a word, the progress as a bar, one
+ * action in plain sight per state, and a row with an `href` opening it: a done job's result, or
+ * what runs where it can be followed (a live recording). "Verwijderen" is behind a done job's ⋮. Where every job is done, "Klaar" is left out: in a list of finished work alone
+ * the state is noise.
+ *
+ * A job that changes state is read out once, as a sentence ("Rapport.docx is mislukt. Het
+ * bestand is beschadigd."), from a status region of its own; the list itself is not live, so a
+ * moving percentage does not chatter. It never fetches: the host sets `jobs` again when a job
+ * moves. When the last job goes with the focus on it, the focus goes to that region.
+ *
+ * Events: `lintje-job-cancel`, `lintje-job-retry`, `lintje-job-resume`, `lintje-job-remove`
+ * (detail: the job's id), `lintje-navigate` `{ href }` (a row with an `href`; cancel it to route).
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../tables/list/list.js';
+import type { ListItem } from '../../tables/list/list.js';
+export type JobState = 'queued' | 'busy' | 'paused' | 'done' | 'error' | 'cancelled';
+export interface Job {
+    id: string;
+    name: string;
+    state: JobState;
+    /** One line under the name: the step and time left, the queue place, or the error reason. */
+    detail?: string;
+    /** 0–100, for a busy job or where a paused one broke off. */
+    progress?: number | null;
+    /** Where it opens: a done job's result, or work that can be followed while it runs. */
+    href?: string;
+    /** The kind of work, as an icon file name. */
+    icon?: string;
+    /** The moment, on the right: "vandaag 10:12". */
+    meta?: string;
+    /** The heading consecutive jobs stand under ("Vandaag"). */
+    group?: string;
+}
+/** The sentence for a job's new state; a failure says why, when the job says it. */
+export declare function spokenState(job: Job): string;
+/** A job as a work-list row: its state, its bar while it runs, and its one action. */
+export declare function jobRow(job: Job, quiet?: boolean): ListItem;
+export declare class LintjeJobList extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    jobs: Job[];
+    /** The level of a group's heading ("Vandaag"), as on `lintje-list`. */
+    headingLevel: 2 | 3 | 4 | 5 | 6;
+    spoken: string;
+    private known;
+    private emptiedWithFocus;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private onAction;
+    private onRowClick;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-job-list': LintjeJobList;
+    }
+}

package/dist-elements/types/components/feedback/level-meter/level-meter.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `<lintje-level-meter>` — how loud the sound comes in, as bars with a word beside them: before a
+ * recording to show the microphone works, during it to show it still does. The host measures and
+ * sets `level` as often as it likes; the bars follow, without motion under reduced motion.
+ *
+ * `null` is not measured yet: flat bars and a dash, never "Stil" (rule 15).
+ *
+ * Events: none.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+/** The level's word: silence and a soft voice are worth saying, everything above is fine. */
+export declare function levelWord(level: number): string;
+export declare class LintjeLevelMeter extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    /** The sound coming in, 0 to 1; `null` before it is measured. */
+    level?: number | null;
+    /** Draw the word beside the bars; without, the host says it (it is still the bars' name). */
+    words: boolean;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-level-meter': LintjeLevelMeter;
+    }
+}

package/dist-elements/types/components/feedback/recording-status/recording-status.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `<lintje-recording-status>` — how a running recording is doing, in the description list's cells:
+ * how long it runs, how the sound comes in and, for a recording made elsewhere (a phone), how the
+ * connection holds. Each meter has its word beside it, so the colour never speaks alone (rule 13).
+ *
+ * The host measures; the element only shows. A value it does not have is a dash, never zero.
+ *
+ * Events: none.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import { levelWord } from '../level-meter/level-meter.js';
+import '../level-meter/level-meter.js';
+import '../../tables/description-list/description-list.js';
+export { levelWord };
+export type RecordingConnection = 'good' | 'weak' | 'lost';
+/** `12:04`, or `1:02:09` from an hour on. */
+export declare function clockOf(seconds: number): string;
+export declare class LintjeRecordingStatus extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    /** How long it runs, in seconds. */
+    elapsed?: number | null;
+    /** The sound coming in, 0 to 1. */
+    level?: number | null;
+    /** Only for a recording made elsewhere; without it the connection is not shown. */
+    connection?: RecordingConnection | null;
+    /** How far the text here runs behind, in seconds. */
+    delay?: number | null;
+    private renderLevel;
+    private renderConnection;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-recording-status': LintjeRecordingStatus;
+    }
+}

package/dist-elements/types/components/feedback/streaming-text/streaming-text.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `<lintje-streaming-text>` — text that streams in while the server writes it. Plain text, never
+ * HTML; a host wanting prose slots a `<lintje-prose>` once the stream is `done`. A screen reader
+ * hears it per sentence from a polite live region; the visible box is `aria-busy` until the end.
+ * The host owns the connection and sets `text` and `state`. `variant="plain"` drops the box and
+ * takes the type of where it stands, for a surface that frames the text itself.
+ *
+ * Events: `lintje-stop` ("Stoppen"), `lintje-retry` ("Opnieuw").
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/button/button.js';
+import '../../../primitives/spinner/spinner.js';
+import { sentenceEnd } from '../../shared/sentence-end.js';
+export { sentenceEnd };
+export type StreamState = 'waiting' | 'streaming' | 'done' | 'stopped' | 'error';
+export declare class LintjeStreamingText extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    text: string;
+    state: StreamState;
+    /** What happened, for `error`. Without it: the connection dropped and the text is not done. */
+    message?: string;
+    label: string;
+    /** `box` (default): the text in a framed box; `plain`: no box, the type of where it stands. */
+    variant: 'box' | 'plain';
+    spoken: string[];
+    private said;
+    /** "Stoppen" had the focus: hand it to "Opnieuw" once that renders. */
+    private focusRetry;
+    private get ended();
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private stop;
+    private renderBox;
+    private renderFoot;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-streaming-text': LintjeStreamingText;
+    }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * `<lintje-toast>` — the toast: a glyph carries the meaning, so colour is not the only signal
+ * (rule 13). An error, and a toast with an action, stay until closed. A plain `ok` toast closes
+ * after six seconds; the pointer on it or the focus in it holds it, and its six seconds start
+ * again when both have left. Closing with the focus inside, it gives the focus back first.
+ *
+ * It is a `role="status"` region drawn empty first, its content going in on the next frame: a
+ * region that arrives together with its text is not announced, one that is filled is.
+ *
+ * Events: `lintje-close` (timed out or closed), `lintje-action`. The host owns whether it exists.
+ */
+import { type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+export declare class LintjeToast extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    /** `ok` closes itself after six seconds, unless it has an action; `error` stays. */
+    kind: 'ok' | 'error';
+    /** The label of the one action, e.g. "Ongedaan maken". Without it there is none. */
+    action?: string;
+    filled: boolean;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    protected render(): TemplateResult;
+    /** The mark, the message, the action and the close: what goes into the region. */
+    private content;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-toast': LintjeToast;
+    }
+}

package/dist-elements/types/components/filters/filter-bar/filter-bar.d.ts

@@ -0,0 +1,57 @@
+/**
+ * `<lintje-filter-bar>` — the host's declared filters in the filter zone and, below 768 px,
+ * the sheet. Values cross as the canonical strings the host writes to the URL. A change in the
+ * bar commits at once; the sheet commits on "Toepassen". The host confirms with the next
+ * `data`. Put one filter bar on a page: two would both write the count and own the sheet.
+ */
+import { type PropertyDeclarations, type TemplateResult, type PropertyValues } from 'lit';
+import { LintjeElement, type FrameSettings } from '../../../core/element.js';
+import '../../inputs/field/field.js';
+import '../../inputs/segmented/segmented.js';
+import '../../inputs/select/select.js';
+import '../../inputs/multiselect/multiselect.js';
+import '../../inputs/range/range.js';
+import '../../inputs/date-range/date-range.js';
+import '../../inputs/toggle/toggle.js';
+import '../../inputs/text-input/text-input.js';
+import '../../inputs/number-input/number-input.js';
+import '../filter-zone/filter-zone.js';
+import '../filter-sheet/filter-sheet.js';
+import type { FilterBarData, FilterValue } from '../../../types.js';
+type Values = Record<string, FilterValue>;
+export declare class LintjeFilterBar extends LintjeElement {
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    data?: FilterBarData | null;
+    protected get dataSettings(): FrameSettings | undefined;
+    values: Values;
+    /** The sheet's draft: nothing applies before "Toepassen". */
+    draft: Values;
+    open: boolean;
+    private readonly mobile;
+    private readonly frame;
+    private sheetWasOpen;
+    private committed;
+    private declaredOpen;
+    private get filters();
+    /**
+     * A `hidden` filter has its control in a tile, which writes the same URL key: the bar does
+     * not draw it, count it in "n van m afwijkend" or reset it with "Herstel standaard".
+     */
+    private get visible();
+    private get defaults();
+    protected willUpdate(changed: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    private isModified;
+    private get modifiedCount();
+    private commit;
+    private control;
+    private fields;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-filter-bar': LintjeFilterBar;
+    }
+}
+export {};

package/dist-elements/types/components/filters/filter-sheet/filter-sheet.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `<lintje-filter-sheet>` — the filters below 768 px. Nothing applies before "Toepassen"; the
+ * owner keeps the draft and supplies the controls. Escape in an open popover closes only that
+ * popover. Focus is trapped while open (`FocusTrap`).
+ *
+ * Events (bubbling, not composed): `lintje-filters-apply`, `lintje-sheet-close`,
+ * `lintje-filters-reset`.
+ */
+import { nothing, type PropertyDeclarations, type TemplateResult, type PropertyValues } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/button/button.js';
+import '../../../primitives/icon-button/icon-button.js';
+import { type SentencePart } from '../shared/sentence.js';
+export declare class LintjeFilterSheet extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    open: boolean;
+    resetDisabled: boolean;
+    applyDisabled: boolean;
+    /** The sentence for the draft. */
+    sentence: SentencePart[];
+    /** The element that scrolls the page; without it the sheet uses `lockScroll`. */
+    scrollLock?: HTMLElement | null;
+    private locked;
+    private readonly onKeyDown;
+    private hasOpenPopover;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private close;
+    private lock;
+    private unlock;
+    protected updated(changed: PropertyValues<this>): void;
+    protected render(): TemplateResult | typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-filter-sheet': LintjeFilterSheet;
+    }
+}

package/dist-elements/types/components/filters/filter-zone/filter-zone.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `<lintje-filter-zone>` — the filter bar: one place for everything that narrows the numbers.
+ *
+ * Expanded, scrolled (a sticky summary bar) and mobile (sentence only) states: see `zone-state.ts`.
+ * The controls come in through the slot, the sentence as parts; the owner keeps the state.
+ *
+ * Events (bubbling, not composed): `lintje-filters-reset`, `lintje-zone-open-change` (boolean),
+ * `lintje-zone-scrolled-change` (boolean).
+ */
+import { type PropertyDeclarations, type TemplateResult, type PropertyValues } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import { type SentencePart } from '../shared/sentence.js';
+export declare class LintjeFilterZone extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    total: number;
+    modified: number;
+    /** The reader's choice to show the controls, held in the owner's URL. */
+    open: boolean;
+    scrolled: boolean;
+    /** The open transition is done, so the body may stop clipping the popovers hanging out of it. */
+    protected settled: boolean;
+    private settleTimer;
+    /** The stuck panel is taller than the space below the top bar. Scrolling clips popovers. */
+    protected scrollable: boolean;
+    /** `fixed` where the zone's own box is too small to stick in (a component mount). */
+    stick: 'sticky' | 'fixed';
+    sentence: SentencePart[];
+    private readonly mobile;
+    private observer;
+    private observed;
+    private wasExpanded;
+    private readonly onResize;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private measureOverflow;
+    private timeSettling;
+    private stopObserving;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private report;
+    private canPin;
+    private get state();
+    private act;
+    private readonly onPageScroll;
+    private pageScroll;
+    private watchPageScroll;
+    protected render(): TemplateResult;
+    private renderHeader;
+    private renderSummaryBar;
+    private renderToggle;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-filter-zone': LintjeFilterZone;
+    }
+}

package/dist-elements/types/components/filters/filter-zone/zone-state.d.ts

@@ -0,0 +1,43 @@
+/**
+ * When the filter zone shows its controls: closed until the reader opens it.
+ * `open` is the reader's choice; `scrolled` (the zone touches the top bar) only moves the bar.
+ * Kept apart from the element so the transitions test without a DOM.
+ */
+export interface ZoneState {
+    open: boolean;
+    scrolled: boolean;
+}
+export type ZoneAction = {
+    type: 'expand';
+} | {
+    type: 'collapse';
+} | {
+    type: 'scrolled';
+    scrolled: boolean;
+}
+/** The page moved under the open controls, `distance` px from where they were opened. */
+ | {
+    type: 'page-scrolled';
+    distance: number;
+};
+/** How far, in px, the page may move under the open controls before they close. */
+export declare const SCROLL_CLOSES_AFTER = 24;
+export declare function zoneExpanded(state: ZoneState): boolean;
+/** A page that scrolls on under the open controls closes them, past a small tremble. */
+export declare function zoneReduce(state: ZoneState, action: ZoneAction): ZoneState;
+/**
+ * Whether the reader can stay past the threshold once the zone pins. Pinning takes `lost` px out
+ * of the page, so its furthest scroll position moves up as much; where that falls short of the
+ * threshold the browser scrolls the reader back above it, the zone unpins and the page grows
+ * again — open, pinned, open with every turn of the wheel. Then the zone stays in the page.
+ */
+export declare function canStayScrolled(page: {
+    /** The scroller's `scrollHeight` before pinning. */
+    scrollHeight: number;
+    /** The scroller's `clientHeight`. */
+    viewportHeight: number;
+    /** The height pinning takes out of the page. */
+    lost: number;
+    /** The scroll position at which the zone reaches the top bar. */
+    threshold: number;
+}): boolean;

package/dist-elements/types/components/filters/shared/sentence.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The "Je ziet" sentence, rendered from parts the filter owner writes.
+ * A function, not an element: the zone, sheet and bar style it from outside, which only
+ * reaches it inside the same shadow root.
+ */
+import { type TemplateResult } from 'lit';
+export interface SentencePart {
+    text: string;
+    emphasis: boolean;
+}
+export declare function filterSentence(parts: SentencePart[], showIcon?: boolean): TemplateResult;
+/** The sentence as plain text, for the export footer and the shared link. */
+export declare function sentenceText(parts: SentencePart[]): string;

package/dist-elements/types/components/forms/error-summary/error-summary.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `<lintje-error-summary>` — the error summary above a form, with a link to each field.
+ *
+ * With nothing to show it draws nothing. A link focuses the field, found by `name` or `id` in
+ * the summary's own tree and, from a shadow root, in its host's light DOM (where `lintje-form`
+ * draws it). The field is scrolled to the middle of the view, clear of a sticky top bar and of the
+ * action bar below, however deep it stands in the form.
+ * It never validates. `focus()` puts the focus on the frame (`tabindex="-1"`).
+ *
+ * Events: `lintje-retry` from the "Opnieuw proberen" button.
+ */
+import { nothing, type PropertyDeclarations, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import '../../../primitives/button/button.js';
+/** `field` is the field's `name`; without it (a field not on the page) the line is plain text. */
+export interface ErrorSummaryItem {
+    field?: string;
+    label?: string;
+    message: string;
+}
+export declare function summaryHeading(count: number): string;
+/** Searches the summary's tree, then each host's light DOM outwards to the document. */
+export declare function findField(from: Node, field: string): HTMLElement | null;
+export declare class LintjeErrorSummary extends LintjeElement {
+    static styles: import("lit").CSSResult[];
+    static properties: PropertyDeclarations;
+    /** The field errors, in the order of the form. */
+    items: ErrorSummaryItem[];
+    /** The error that belongs to no field: one sentence. */
+    message?: string;
+    /** Overrides the default heading (the count, or "Opslaan is niet gelukt"). */
+    heading?: string;
+    /** The label of the retry button under `message`; without it there is none. */
+    retry?: string;
+    get hasErrors(): boolean;
+    focus(options?: FocusOptions): void;
+    private goTo;
+    protected render(): TemplateResult | typeof nothing;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-error-summary': LintjeErrorSummary;
+    }
+}

package/dist-elements/types/components/forms/form/controls.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What `lintje-form`, `lintje-form-section` and `lintje-form-actions` share: finding the controls
+ * in their light DOM, and setting a property on them that can be handed back.
+ *
+ * A `<fieldset disabled>` in a shadow root disables nothing slotted into it, so each holder
+ * disables controls itself and hands back the state it found, or a control the host had
+ * disabled comes back enabled.
+ */
+/** The control's `name` property, or its `name` attribute before it upgraded. */
+export declare function controlName(element: Element): string;
+/** Every light-DOM element below `root` that can be disabled. */
+export declare function disableableControls(root: ParentNode): HTMLElement[];
+export declare function namedControls(root: ParentNode): HTMLElement[];
+/** The named controls in an added or removed node: the node itself and those below it. */
+export declare function namedControlsIn(node: Node): HTMLElement[];
+export declare function readControl(control: HTMLElement): unknown;
+/** Returns `false` for a control that cannot take a value back. */
+export declare function writeControl(control: HTMLElement, value: unknown): boolean;
+/**
+ * What a control posts in a native `<form>`, from the value `readControl` gives: a boolean posts
+ * `on` or nothing, a list repeats the name, a `{ from, to }` pair posts `name-from`, `name-to`.
+ */
+export declare function formEntries(name: string, value: unknown): [string, string][];
+/** A control that tells its own changes (`lintje-change`); a native one has to be read. */
+export declare function announces(control: HTMLElement): boolean;
+/** A `lintje-…` host does not delegate focus, so `host.focus()` is a no-op: focus goes inside. */
+export declare function focusInside(element: HTMLElement, options?: FocusOptions): void;
+/** `apply()` remembers the value it first found on an element; `release()` writes it back. */
+export declare class PropertyHold {
+    #private;
+    constructor(property: string);
+    get active(): boolean;
+    apply(elements: Iterable<HTMLElement>, value: unknown): void;
+    release(): void;
+}
+/** `PropertyHold` for a boolean attribute that is not a property (`block` is CSS only). */
+export declare class AttributeHold {
+    #private;
+    constructor(attribute: string);
+    apply(elements: Iterable<HTMLElement>, on: boolean): void;
+    release(): void;
+}

package/dist-elements/types/components/forms/form/form.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `<lintje-form>` — collects the values of its light-DOM fields, keeps the draft, asks for one
+ * submit and puts the host's errors under their fields.
+ *
+ * Its `<form>` is in the shadow root, so slotted fields have no form owner: the form's own key
+ * and click handlers are the one submit. `lintje-values-change` is stopped so form input never
+ * reaches the URL.
+ *
+ * Events: `lintje-submit` `{ values }`, `lintje-invalid` (the errors), `lintje-dirty-change`
+ * (boolean).
+ */
+import { type PropertyDeclarations, type PropertyValues, type TemplateResult } from 'lit';
+import { LintjeElement } from '../../../core/element.js';
+import type { FormActionsState } from '../form-actions/form-actions.js';
+import '../error-summary/error-summary.js';
+import '../form-actions/form-actions.js';
+export type FormValues = Record<string, unknown>;
+/** What the host hands back after a failed attempt: per field, and what belongs to no field. */
+export interface FormErrors {
+    fields: Record<string, string>;
+    form?: string;
+}
+export interface StoredDraft {
+    savedAt: number;
+    values: FormValues;
+}
+export declare const DRAFT_PREFIX = "lintje-draft:";
+/** The stored draft, or `null` when there is none, it is unreadable, or it is older than `ttl` hours. */
+export declare function readDraft(key: string, ttlHours: number, now?: number): StoredDraft | null;
+export declare class LintjeForm extends LintjeElement {
+    #private;
+    static styles: import("lit").CSSResult;
+    static properties: PropertyDeclarations;
+    /** What is saved. The form writes it into the fields and compares every change with it. */
+    values: FormValues;
+    /** The host's answer to a failed attempt. */
+    errors?: FormErrors;
+    busy: boolean;
+    /** When it was last saved ("10:42" or an ISO moment); `saved()` sets it. */
+    savedAt?: string;
+    /** Keeps the draft in `localStorage` under `lintje-draft:<key>`. Without it: memory only. */
+    draftKey?: string;
+    /** Hours a stored draft stays good. */
+    draftTtl: number;
+    /** The draft differs from `values`. Reflected; the form sets it, a host reads it. */
+    dirty: boolean;
+    protected phase: Exclude<FormActionsState, 'busy'>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** The values to send: `values` with the draft over it; silent and native controls are read. */
+    collect(): FormValues;
+    /** Drops a field from `values` and the draft; the form does this when a named field leaves. */
+    forget(name: string): void;
+    /**
+     * The draft put back from `localStorage`, readable before any field exists so a host can build
+     * the rows it needs. A copy; `null` without a stored draft. Set `draft-key` and `draft-ttl`
+     * before the first read: the store is read once.
+     */
+    get restoredDraft(): FormValues | null;
+    /** When the restored draft was written; `null` when there is none. */
+    get restoredAt(): Date | null;
+    /** Asks the host to save; does nothing while `busy`. */
+    submit(): void;
+    /** The host's word that the save succeeded. */
+    saved(at?: Date): void;
+    /** Keeps the draft now (Ctrl+S). Without `draft-key` nothing is stored or said. */
+    saveDraft(): void;
+    discardDraft(): void;
+    protected willUpdate(changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lintje-form': LintjeForm;
+    }
+}