@eifi1/ui-kit 0.21.0 → 0.23.0

package/dist/{kit-labels-D1J2_jyD.d.ts → feedback-BxeQVzwq.d.ts}

@@ -1,12 +1,14 @@
+import { l as FeedbackAttachmentLabels, k as FeedbackAttachmentFieldSingleProps, g as FeedbackAttachmentFieldLabels, u as FeedbackDialogTextLabels } from './feedback-attachment-fGAzZPf0.js';
+import { FeedbackNoteAttachment } from './feedback/feedback-inbox.js';
 import * as react from 'react';
-import { AnchorHTMLAttributes, Ref, ReactElement, ButtonHTMLAttributes, ReactNode, SelectHTMLAttributes, ComponentPropsWithoutRef, InputHTMLAttributes, TextareaHTMLAttributes } from 'react';
-import { DataTableLabels } from './components/data-table-labels.js';
+import { InputHTMLAttributes, ReactNode, AnchorHTMLAttributes, Ref, ReactElement, ButtonHTMLAttributes, SelectHTMLAttributes, ComponentPropsWithoutRef, TextareaHTMLAttributes } from 'react';
+import { TooltipSide } from './components/tooltip.js';
+import { f as DataTableLabels } from './data-table-labels-B7OdnM0S.js';
 import { MiniCalendarLabels, WeekDay } from './components/mini-calendar.js';
 import { CalendarHeatmapLabels } from './components/calendar-heatmap.js';
 import { PopoverLabels } from './components/popover.js';
 import { ChipInputLabels } from './components/chip.js';
 import { FieldSyncLabels } from './components/field-sync.js';
-import { TooltipSide } from './components/tooltip.js';
 import { WizardLabels } from './wizard/types.js';
 import { TourLabels } from './tour/tour.js';
 import { CommandPaletteLabels } from './search/command-palette.js';
@@ -19,15 +21,11 @@ import { SparklineLabels } from './components/sparkline.js';
 import { StatTileLabels } from './components/stat-tile.js';
 import { SignaturePadLabels } from './components/signature-pad.js';
 import { PasswordStrengthLabels } from './components/password-strength.js';
-import { DangerConfirmLabels } from './components/danger-confirm.js';
 import { SwatchPickerLabels } from './components/swatch-picker.js';
 import { IconPickerLabels } from './components/icon-picker.js';
 import { DialogFrameProps, DialogFrameLabels } from './components/dialog-frame.js';
 import { MeasuredGridLabels } from './components/measured-grid.js';
-import { f as FeedbackAttachmentFieldLabels, q as FeedbackDialogTextLabels } from './feedback-attachment-WFiXJ8We.js';
-import { FeedbackThreadLabels, FeedbackComposerLabels } from './feedback/feedback-thread.js';
 import { AccountSettingsLabels } from './components/account-settings-labels.js';
-import { ConfirmDialogLabels } from './components/confirm-dialog.js';
 import { FloatingPanelLabels } from './components/floating-panel.js';
 import { BulkActionBarLabels } from './components/bulk-action-bar.js';
 import { ListLabels } from './components/list.js';
@@ -48,6 +46,13 @@ import { RoleDefinition, AccountStateLabels } from './components/account-chips.j
 import { ReauthDialogLabels } from './components/reauth-dialog.js';
 import { ServerWakeLabels } from './components/server-wake.js';
 import { TranslationReviewLabels } from './components/translation-review-labels.js';
+import { CountrySelectLabels } from './components/country-select.js';
+import { InlineEditLabels } from './components/inline-edit-field.js';
+import { IbanKind } from './lib/iban.js';
+import { PhoneCountry, PhoneCountryCode } from './lib/phone.js';
+import { SignChipLabels } from './components/sign-chip.js';
+import { ColumnMapperLabels } from './components/column-mapper.js';
+import './components/field-parts.js';
 
 type ButtonVariant = "primary" | "secondary" | "ghost" | "danger" | "brand" | "link";
 type ButtonSize = "sm" | "md";
@@ -565,7 +570,6 @@ type FieldChevronProps = Omit<ComponentPropsWithoutRef<"svg">, "children">;
  * what was picked. */
 declare function FieldChevron({ className, ...rest }: FieldChevronProps): react.JSX.Element;
 declare const FLOATING_LABEL_CLASS: string;
-declare const FLOATING_LABEL_STATIC: string;
 /**
  * The one place that assembles a labelled field: a `relative` wrapper around the
  * control (`children`) plus a floating label inside the top strip. Pass `staticLabel`
@@ -622,15 +626,6 @@ interface FieldHintProps extends Omit<ComponentPropsWithoutRef<"button">, "child
     side?: TooltipSide;
 }
 declare function FieldHint({ label, side, className, "aria-label": ariaLabel, ...rest }: FieldHintProps): react.JSX.Element;
-/**
- * The floating label for a custom-dropdown trigger (a `<span>`, since the trigger is a
- * button not a labelable input). Same placement as {@link FloatingField}'s static label,
- * so every labelled field lines up. Render inside a `relative` wrapper, before the trigger.
- */
-interface FieldLabelProps extends ComponentPropsWithoutRef<"span"> {
-    children: ReactNode;
-}
-declare function FieldLabel({ children, className, ...rest }: FieldLabelProps): react.JSX.Element;
 interface LabelProps extends ComponentPropsWithoutRef<"label"> {
     /** Draw the required mark after the text. The mark is `aria-hidden`: what a
      *  screen reader hears is the control's own `required` / `aria-required`, which
@@ -669,6 +664,22 @@ declare const DEFAULT_PASSWORD_REVEAL_LABELS: PasswordRevealLabels;
 /** Caller's labels over the English defaults — the same shape as
  *  `resolveDataTableLabels`, so a consumer translates every kit string one way. */
 declare function resolvePasswordRevealLabels(partial?: Partial<PasswordRevealLabels>): PasswordRevealLabels;
+/**
+ * What the character counter of {@link Input} and {@link Textarea} (`showCount`) says.
+ * The visible "12/80" is digits and a slash and is not translated; these are the words
+ * a screen reader gets instead of it.
+ */
+interface CharacterCountLabels {
+    /** The counter as part of the field's description, read when focus reaches the
+     *  field: "12 of 80 characters". */
+    count: (used: number, max: number) => string;
+    /** Said once, politely, on entering the last stretch before the limit: "8
+     *  characters left". */
+    remaining: (left: number) => string;
+    /** Said once, politely, on reaching the limit. */
+    limitReached: string;
+}
+declare const DEFAULT_CHARACTER_COUNT_LABELS: CharacterCountLabels;
 interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
     label?: ReactNode;
     /** Classes for the `<input>` itself, as distinct from `className`, which
@@ -699,6 +710,30 @@ interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
      *  `invalid`, so the field paints as well as announces. `invalid` alone still
      *  covers the case where the message lives elsewhere. See {@link useFieldError}. */
     error?: ReactNode;
+    /**
+     * Standing advice for the field (keksdose K4: Input had `error` but no `hint`, so the
+     * app built the caption by hand under each field, and half of those never reached a
+     * screen reader). The {@link Select} rule, so every field reads alike:
+     *  - plain TEXT (a string or a number) is a caption UNDER the field, attached with
+     *    `aria-describedby` — after the caller's own ids, before the error's;
+     *  - anything else (a {@link FieldHint} "?") rides the label line beside the
+     *    animated label, as NumberInput's does — or, on a field with no label, sits at the
+     *    field's end edge outside the box, and `className` then styles that row.
+     */
+    hint?: ReactNode;
+    /**
+     * A live "12/80" under the field, with `maxLength` (keksdose K11 — the broadcast,
+     * support and handoff-note fields counted by hand). Read with the field as "12 of 80
+     * characters", and announced politely only on entering the last stretch and on
+     * reaching the limit — never on every keystroke. See {@link CharacterCount}. Ignored
+     * without a `maxLength`: a count with no limit is not what this answers. Counts
+     * UTF-16 code units, as `maxLength` itself does. Controlled, it counts `value`;
+     * uncontrolled, `defaultValue` and then every change event — a value written from
+     * outside without one (a form library's `reset`) shows from the next keystroke.
+     */
+    showCount?: boolean;
+    /** The counter's words. See {@link CharacterCountLabels}. */
+    countLabels?: Partial<CharacterCountLabels>;
     /** Names for the password reveal toggle, English by default — it is the one
      *  string this component renders on its own behalf, and a German form was
      *  reading it out in English. See {@link PasswordRevealLabels}. */
@@ -735,6 +770,29 @@ interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "siz
      *  the chevron is positioned against — so it could set a width and nothing
      *  else; this is the way to the element. See {@link Input}'s `inputClassName`. */
     selectClassName?: string;
+    /**
+     * Why the choice cannot be changed — {@link Button}'s `disabledReason`, for a select
+     * that SAVES on change (a role picker in a members table, a status in a row). keksdose
+     * K3: those sat inside a hand-rolled `SaveGuard` that forced a native `disabled`, which
+     * took the field out of the tab order so the reason never reached a keyboard.
+     *
+     * With a reason the select is `aria-disabled` instead — still focusable, still showing
+     * its value — its list does not open (pointer and keys are swallowed, Tab and Escape
+     * excepted), `onChange` is never called, and the reason is in the kit {@link Tooltip}
+     * and on `aria-describedby`. It wears the settled look of a disabled field and drops
+     * its chevron, as a disabled Select does (dev#474). It wins over `disabled`.
+     *
+     * Use it CONTROLLED (`value` + `onChange`): React puts a controlled value back after
+     * the swallowed change. A touch platform's own picker may still open; nothing it picks
+     * is kept or reported.
+     */
+    disabledReason?: ReactNode;
+    /**
+     * This select COMMITS — choosing saves. Under a locked {@link WriteLockProvider} it is
+     * locked the `disabledReason` way with the lock's reason (which wins over its own).
+     * No provider, or an unlocked one: no effect. Button's `commit`, for keksdose K3.
+     */
+    commit?: boolean;
 }
 declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
 interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
@@ -743,6 +801,14 @@ interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     invalid?: boolean;
     /** See {@link Input}'s `error`. */
     error?: ReactNode;
+    /** See {@link Input}'s `hint` (keksdose K4): text is a caption under the field, a
+     *  {@link FieldHint} rides the label line (or, unlabelled, the end edge). */
+    hint?: ReactNode;
+    /** See {@link Input}'s `showCount` (keksdose K11): a live "12/80" under the field,
+     *  with `maxLength`, announced only near and at the limit. */
+    showCount?: boolean;
+    /** The counter's words. See {@link CharacterCountLabels}. */
+    countLabels?: Partial<CharacterCountLabels>;
 }
 declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
 interface CardProps extends ComponentPropsWithoutRef<"div"> {
@@ -1164,6 +1230,375 @@ interface TabsProps<T extends string> extends Omit<ComponentPropsWithoutRef<"div
 }
 declare function Tabs<T extends string>({ tabs, active, onChange, className, wrap, label, panelId, onRemove, removeOn, onAdd, addLabel, labels, busy, orientation, "aria-label": ariaLabel, ...rest }: TabsProps<T>): react.JSX.Element;
 
+/**
+ * How typed text is compared with the text it has to repeat — shared by
+ * `DangerConfirm`'s `phraseMatch` and `useConfirm`'s `typedMatch`.
+ *
+ * - `"trim"` ignores spaces around the typed text — a phone keyboard's autocomplete
+ *   likes to add one. Case counts: "delete" is not "DELETE".
+ * - `"exact"` compares character for character, spaces included.
+ * - `"caseless"` trims AND ignores case: for an e-mail address, whose domain is
+ *   case-insensitive and whose local part every real mail server treats so. Both apps'
+ *   "type the account's address" rules (keksdose's `TYPE_EMAIL`, Kurvenschmiede's
+ *   `TypedConfirm`) compared `trim().toLowerCase()`, and a capital the user's keyboard
+ *   put at the start must not make the right row look like the wrong one.
+ */
+type TypedMatch = "trim" | "exact" | "caseless";
+/** Whether `typed` repeats `target` under `mode` — see {@link TypedMatch}. Exported for
+ *  a caller that draws its own field (a dialog that also picks a recipient) and wants
+ *  the same rule as the kit's. */
+declare function typedMatches(typed: string, target: string, mode?: TypedMatch): boolean;
+/**
+ * Busy-while-a-promise-runs, for an action that MAY return one: `run(result, onResolved)`
+ * marks the caller pending until `result` settles, calls `onResolved` if it fulfilled,
+ * and only clears the flag if it rejected — the caller shows why and the user retries.
+ * Nothing runs after unmount. Shared by `DangerConfirm` and `ReauthDialog`, whose
+ * contract is the same: resolve = done, reject = stay put.
+ *
+ * @internal
+ */
+declare function usePromisePending(): {
+    pending: boolean;
+    run: (result: unknown, onResolved: () => void) => boolean;
+};
+/** The one word {@link CurrentPasswordInput} says on its own behalf — the
+ *  `dangerConfirm.password` label, shared with DangerConfirm's password field, so an
+ *  app translates "Password" once. */
+type CurrentPasswordInputLabels = Pick<DangerConfirmLabels, "password">;
+/**
+ * Everything {@link Input} takes except what makes this field what it is: `type` is
+ * always `"password"` and `autoComplete` always `"current-password"`.
+ */
+interface CurrentPasswordInputProps extends Omit<InputProps, "type" | "autoComplete" | "label"> {
+    /**
+     * The visible label. Default `dangerConfirm.password` ("Password") — unless the field
+     * is named another way (`aria-label` / `aria-labelledby`), which then stays the only
+     * name. Pass the app's own word on a sign-in form ("Password", "Your password"), or
+     * `null` for a field whose `<label htmlFor>` is drawn elsewhere (a form library's
+     * `FormLabel`), which would otherwise be labelled twice.
+     */
+    label?: ReactNode;
+    /** The value as a string — the `(next) => …` shape, so a caller holding it in
+     *  `useState` need not unwrap `event.target.value`. Fires alongside `onChange`,
+     *  never instead of it, so a form library's `onChange` keeps working. */
+    onValueChange?: (value: string) => void;
+    /**
+     * A check is running (the sign-in request, the re-auth). The field turns `readOnly`,
+     * NOT `disabled`: the field being submitted is usually the focused one (Enter was
+     * pressed in it), and disabling a focused field drops focus to `<body>` — the user
+     * lands nowhere when the "wrong password" answer comes back.
+     */
+    busy?: boolean;
+    /** Per-instance override of `dangerConfirm.password`. */
+    labels?: Partial<CurrentPasswordInputLabels>;
+}
+/**
+ * The "prove it is you" field: a password input that a password manager fills with
+ * the CURRENT password and never offers to generate a new one for.
+ *
+ * It is the field of a sign-in form, a re-auth step ({@link ReauthDialog} draws the same
+ * field), and {@link DangerConfirm}'s `requirePassword`. Public since 0.22 for kastlan's
+ * sign-in and re-auth (kastlan 1), which wrote `type="password"` +
+ * `autoComplete="current-password"` by hand — and a sign-in field that forgets the
+ * second half gets the browser's "suggest a strong password" offer on the one form where
+ * a NEW password is never what is wanted. The reverse matters as much: a field that sets
+ * a NEW password (a passphrase, a sign-up) must NOT be this one — keksdose #170 keeps
+ * its passphrase doors on `new-password` / `off` for that reason.
+ *
+ * Everything else is {@link Input}: the reveal toggle, `error` (under the field,
+ * `aria-describedby`, `aria-invalid`), `invalid`, `name`, `id`, `autoFocus`, `required`.
+ * The ref is the `<input>`, so it works with `@eifi1/ui-kit/rhf`'s `FormControl` /
+ * a `register()` spread, and controlled or uncontrolled.
+ *
+ * ```tsx
+ * <CurrentPasswordInput name="password" label={t("password")} error={errors.password?.message}
+ *   busy={isSubmitting} {...register("password")} />
+ * ```
+ */
+declare const CurrentPasswordInput: react.ForwardRefExoticComponent<CurrentPasswordInputProps & react.RefAttributes<HTMLInputElement>>;
+/** The words {@link TypedConfirmField} says on its own behalf — the `dangerConfirm`
+ *  namespace's `phrase` and `phrasePlaceholder`, shared with DangerConfirm's own field,
+ *  so the sentence "Type “X” to confirm" is translated once. */
+type TypedConfirmFieldLabels = Pick<DangerConfirmLabels, "phrase" | "phrasePlaceholder">;
+interface TypedConfirmFieldProps extends Omit<InputProps, "type" | "value" | "defaultValue" | "label" | "placeholder"> {
+    /** The text to repeat — a word ("DELETE"), a name, an e-mail address. */
+    target: string;
+    /** How the typed text is compared with `target` — {@link TypedMatch}. Default
+     *  `"trim"`, as {@link typedMatches}; `"caseless"` for an address or an
+     *  acknowledgement word a user may type in any case. */
+    match?: TypedMatch;
+    /** Controlled value. Left out, the field keeps its own (start: `defaultValue`). */
+    value?: string;
+    defaultValue?: string;
+    /** The typed text as a string, on every keystroke. Fires alongside `onChange`. */
+    onValueChange?: (value: string) => void;
+    /**
+     * The typed text started or stopped matching `target` — fired from the keystroke
+     * that flipped it, so an uncontrolled field can still drive the button it guards. A
+     * controlled caller that resets the value itself (on a close) knows the answer
+     * already, and gets no call for that; it can also compute it with {@link typedMatches}.
+     */
+    onMatchedChange?: (matched: boolean) => void;
+    /** The label. Default `dangerConfirm.phrase(target)` — "Type “DELETE” to confirm". */
+    label?: ReactNode;
+    /** Text inside the empty field. Default `dangerConfirm.phrasePlaceholder` (unset).
+     *  Given, the label moves ABOVE the field: a floating label occupies the empty
+     *  field, which is exactly where a placeholder shows. `""` means none. */
+    placeholder?: string;
+    /** The guarded action is running: the field turns `readOnly` (not `disabled`, which
+     *  would drop the focus Enter left in it). */
+    busy?: boolean;
+    labels?: Partial<TypedConfirmFieldLabels>;
+}
+/**
+ * The "type this to confirm" field — {@link DangerConfirm}'s `phrase` field and
+ * `useConfirm({ requireTyped })`'s, on its own (keksdose K7).
+ *
+ * keksdose writes it by hand four times: the privacy enrol, upgrade and sweep dialogs
+ * (type the acknowledgement word, then the key doors appear) and the admin's "type the
+ * user's address" (`UserActionConfirm`), each an `Input` plus its own
+ * `trim().toUpperCase()` / `toLowerCase()` comparison. None of those places is an
+ * arm → confirm tile or a modal confirm — what is guarded is a whole form, or the
+ * next step of a dialog — so the field had to stand alone. What it brings over a plain
+ * `Input`: one match rule ({@link typedMatches}, which lower-cases locale-independently
+ * on purpose), the label worded from the target in the app's language, and the
+ * attributes a phone keyboard needs to leave the text alone (no autocomplete, no
+ * auto-capital, no autocorrect, no spellcheck — a keyboard that "corrects" an e-mail
+ * address makes the guard unpassable).
+ *
+ * The field reports whether it matches (`onMatchedChange`, and `data-matched` on the
+ * `<input>` for styling); what the match unlocks is the caller's. The ref is the
+ * `<input>`.
+ *
+ * ```tsx
+ * const [ok, setOk] = useState(false);
+ * <TypedConfirmField target={t("privacy.enroll_ack_word")} match="caseless" onMatchedChange={setOk} />
+ * {ok && <KeyDoorsForm … />}
+ * ```
+ */
+declare const TypedConfirmField: react.ForwardRefExoticComponent<TypedConfirmFieldProps & react.RefAttributes<HTMLInputElement>>;
+/**
+ * Every string the tile renders — the `dangerConfirm` namespace of
+ * `<UiKitProvider labels>`, overridable per instance through `labels`. The arm and
+ * confirm buttons are usually worded per action ("Delete budget"), which is what the
+ * `armLabel` / `confirmLabel` props are for; these are the fallbacks.
+ */
+interface DangerConfirmLabels {
+    /** The button that arms the tile. */
+    arm: string;
+    /** The button that runs the action once the guards are satisfied. */
+    confirm: string;
+    cancel: string;
+    /** The warning above the fields, when no `prompt` is given. */
+    prompt: string;
+    /** Label of the password field (`requirePassword`). */
+    password: string;
+    /** Label of the type-to-confirm field. A FUNCTION of the phrase by default, like
+     *  every message that carries a value: where the phrase sits in the sentence moves
+     *  with the language. A plain STRING is taken as the finished label — for an app
+     *  whose catalogue already words it ("Type DELETE to confirm") and would otherwise
+     *  wrap it as `() => label`. */
+    phrase: string | ((phrase: string) => string);
+    /** Placeholder of the type-to-confirm field — a string, or a function of the
+     *  phrase (`(p) => p` echoes it). Optional and unset by default: the field keeps its
+     *  floating label, as before. Given, the label moves ABOVE the field (a floating
+     *  label occupies the empty field, which is exactly where a placeholder shows) and
+     *  the placeholder fills the field. An empty string means none. */
+    phrasePlaceholder?: string | ((phrase: string) => string);
+    /** 0.22: the checkbox `requireAcknowledge={true}` shows — "I have read what this does
+     *  and want to continue" (keksdose's `admin.users.confirm_ack`). */
+    acknowledge: string;
+    /**
+     * 0.23: why the armed confirm is held while the typed phrase does not match yet — in
+     * the confirm's tooltip and its description (keksdose G4a). A FUNCTION of the phrase
+     * by default ("Type “DELETE” to confirm"), or a finished STRING, as `phrase`.
+     */
+    needsPhrase: string | ((phrase: string) => string);
+    /** 0.23: why the armed confirm is held while the `requireAcknowledge` box is unticked
+     *  — "Tick the box to confirm". */
+    needsAcknowledge: string;
+    /** 0.23: why the armed confirm is held while the `requirePassword` field is empty —
+     *  "Enter your password to confirm". */
+    needsPassword: string;
+}
+/** `satisfies` rather than a type annotation, so `DEFAULT_DANGER_CONFIRM_LABELS.phrase`
+ *  stays callable for a caller that composes its own label from it. */
+declare const DEFAULT_DANGER_CONFIRM_LABELS: {
+    arm: string;
+    confirm: string;
+    cancel: string;
+    prompt: string;
+    password: string;
+    phrase: (phrase: string) => string;
+    acknowledge: string;
+    needsPhrase: (phrase: string) => string;
+    needsAcknowledge: string;
+    needsPassword: string;
+};
+/**
+ * What the guards were answered with — the second argument of
+ * {@link DangerConfirmProps.onConfirm} (0.23, keksdose G4b). A key is there only when its
+ * guard was asked for, so the object can go into a request body as it is.
+ */
+interface DangerConfirmValues {
+    /**
+     * The text typed into the `phrase` field — as the match rule compared it: trimmed
+     * under `phraseMatch` `"trim"` and `"caseless"` (the spaces a phone keyboard adds are
+     * not part of it), exactly as typed under `"exact"`. The case is the user's, even
+     * under `"caseless"`: a server that re-checks applies its own rule to it. Absent
+     * without a `phrase`.
+     */
+    typed?: string;
+    /** The entered password — the same value as the first argument. Absent without
+     *  `requirePassword`. */
+    password?: string;
+    /** `true` when the `requireAcknowledge` box was shown — it was ticked, since the
+     *  confirm is held until it is. Absent without one. */
+    acknowledged?: true;
+}
+/**
+ * One line of {@link DangerConfirmProps.consequences}: what the action will do. A plain
+ * string, or this, for a key of its own and the `severe` mark.
+ */
+interface DangerConsequence {
+    /** React key — keksdose keys its lines by what they say ("api_tokens", "only_door").
+     *  Default: the text when it is a string, else the position. */
+    key?: string;
+    text: ReactNode;
+    /** "There is no way back" — painted in the danger colour rather than the list's
+     *  muted one. keksdose reserves it for the one line that loses something for good. */
+    severe?: boolean;
+}
+interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    /**
+     * Runs the action, with the entered password when `requirePassword` is on.
+     *
+     * Return a promise and the tile manages itself: busy until it settles, disarmed
+     * (fields wiped) when it resolves, still armed when it rejects — so the user can
+     * correct a wrong password and retry. The rejection is not swallowed for you to
+     * miss: handle it (and show why) in the caller, as with any mutation.
+     *
+     * 0.23: the second argument is what every guard was answered with — the typed phrase,
+     * the password, the tick ({@link DangerConfirmValues}). keksdose G4b: its admin
+     * actions send the address the admin TYPED, and the server re-checks it against the
+     * account (`assert_confirmed`), so a client that put the wrong row's id in the request
+     * is refused rather than obeyed; the tile kept the text to itself.
+     *
+     *     onConfirm={(_password, { typed }) =>
+     *       reset.mutateAsync({ id, confirm: { acknowledged: true, confirm_email: typed ?? null } })}
+     *
+     * A second argument rather than one object in place of the password: every
+     * `(password) => …` and `() => …` handler, and a `mutation.mutate` passed as it is,
+     * keeps working unchanged, and a handler that needs one guard's answer names it.
+     */
+    onConfirm: (password: string | undefined, values: DangerConfirmValues) => void | Promise<unknown>;
+    /** Show a password field; confirm is held until it is filled. */
+    requirePassword?: boolean;
+    /**
+     * Show an "I understand" checkbox; confirm is held until it is ticked
+     * (keksdose K7). `true` words it with `labels.acknowledge`; any other node IS the
+     * checkbox's label ("I understand Anna will be signed out everywhere").
+     *
+     * The guard for an action whose risk is MIS-TARGETING less than carelessness:
+     * keksdose's admin password reset asks for a typed address when the account has an
+     * encrypted door to lose, and a tick otherwise (`UserActionConfirm`), and its plan
+     * editor asks for the tick alone (`UserPlanEditor`). Both were hand-built beside this
+     * tile because it had no tick. It combines with `phrase` and `requirePassword`: every
+     * guard given must be satisfied.
+     */
+    requireAcknowledge?: ReactNode;
+    /**
+     * What the action will do, said before it happens — a list under the prompt, shown
+     * once armed (keksdose K7, `UserActionConfirm`'s consequences). Strings, or
+     * {@link DangerConsequence}s for a `severe` line in the danger colour.
+     *
+     * Derive them from the row's own facts rather than reciting the worst case: an admin
+     * who reads the same paragraph on every row stops reading it (keksdose dev#488).
+     */
+    consequences?: readonly (string | DangerConsequence)[];
+    /** Show a "type <phrase> to confirm" field; confirm is held until the field matches
+     *  (case-sensitive; surrounding spaces ignored unless `phraseMatch="exact"`). */
+    phrase?: string;
+    /**
+     * How the typed text is compared with `phrase`. `"trim"` (default) ignores spaces
+     * around it — a phone keyboard's autocomplete likes to add one. `"exact"` compares
+     * character for character, spaces included, for an app whose contract is "type
+     * exactly this". `"caseless"` (0.18) also ignores case — for a phrase that is an
+     * e-mail address (keksdose's "type the user's address" admin rule). See
+     * {@link TypedMatch}.
+     */
+    phraseMatch?: TypedMatch;
+    /** The warning above the fields. Defaults to `labels.prompt`. */
+    prompt?: ReactNode;
+    /** `"danger"` (default) for what cannot be undone; `"warning"` for what can, at a
+     *  cost (loading demo data over your own). Colours the prompt and the confirm. */
+    tone?: "danger" | "warning";
+    /** Visible text of the arm button; defaults to `labels.arm`. */
+    armLabel?: ReactNode;
+    /** Visible text of the confirm button; defaults to `labels.confirm`. */
+    confirmLabel?: ReactNode;
+    /** The action is running: confirm shows a spinner and nothing can be pressed. For a
+     *  caller that tracks the mutation itself (a `useMutation`'s `isPending`); a
+     *  promise returned from `onConfirm` does the same on its own. */
+    busy?: boolean;
+    /** The arm button is disabled. */
+    disabled?: boolean;
+    /**
+     * Why the action is not available — a read-only demo, a write lock, a missing
+     * permission. Disables the arm button like `disabled`, and SAYS so: the sentence is
+     * shown under the button and attached to it with `aria-describedby`, and the button
+     * stays focusable (`aria-disabled`) so a keyboard user can land on it and hear why.
+     *
+     * On the ARM button rather than the confirm: arming asks for a password, and asking
+     * for a password for a write that can never land is the worse of the two. A tile that
+     * is ALREADY armed when the reason arrives (controlled `armed`, or a lock that landed
+     * while it was open) keeps its fields but its confirm takes the reason the same way
+     * — focusable, `aria-disabled`, the reason in its tooltip — and Enter does nothing.
+     */
+    lockedReason?: ReactNode;
+    /**
+     * This tile COMMITS — the 0.18 write-lock opt-in that {@link Button} has (keksdose
+     * K3). Under a locked {@link WriteLockProvider} the lock's reason becomes
+     * `lockedReason` (and wins over one of the tile's own), so a page that mounts the
+     * provider no longer threads `lockedReason={lock.locked ? lock.reason : undefined}`
+     * into every tile. No provider, or an unlocked one: no effect.
+     */
+    commit?: boolean;
+    /** Controlled armed state. The parent can then collapse the tile from a mutation's
+     *  own `onSuccess` without returning a promise. */
+    armed?: boolean;
+    /** Called with the next armed state — on arm, cancel, and a resolved `onConfirm`. */
+    onArmedChange?: (armed: boolean) => void;
+    /** User-facing strings; see {@link DangerConfirmLabels}. */
+    labels?: Partial<DangerConfirmLabels>;
+}
+/**
+ * An "arm → confirm" tile for destructive actions: one button, which expands into a
+ * warning, an optional list of consequences, an optional "I understand" tick, an
+ * optional type-to-confirm field, an optional password field and a confirm that is held
+ * until every guard is satisfied.
+ *
+ * A held confirm SAYS which guard is still open (0.23, keksdose G4a): it is
+ * `aria-disabled` rather than `disabled` — still focusable, so a keyboard user can land
+ * on it — with the reason in the kit {@link Tooltip} and its description ("Type
+ * “DELETE” to confirm", "Tick the box to confirm", "Enter your password to confirm";
+ * `labels.needs*`), the first open guard in the order they are drawn. FormActions'
+ * `submitDisabledReason` does the same for a form's Save. Pressing it, or Enter in a
+ * field, does nothing. A lock's reason wins over a guard's; while the action runs the
+ * confirm is plainly disabled, its spinner saying why.
+ *
+ * Keksdose hand-rolled it three times (load demo data, wipe everything, reset a
+ * budget) and then as `shared/components/danger-confirm.tsx`; the only app-specific
+ * part was its write-lock hook, which is `lockedReason` here.
+ *
+ * The fields are a `<form>`, so Enter confirms once the guards allow it. They are
+ * wiped every time the tile disarms — a password must not sit in a collapsed tile.
+ * Arming moves focus to the first field (or Cancel, when there is none — never to the
+ * destructive button itself), and disarming moves it back to the arm button, so the
+ * keyboard user is never left on an element that just vanished.
+ */
+declare function DangerConfirm({ onConfirm, requirePassword, requireAcknowledge, consequences, phrase, phraseMatch, prompt, tone, armLabel, confirmLabel, busy: busyProp, disabled, lockedReason: ownLockedReason, commit, armed: armedProp, onArmedChange, labels: labelsProp, className, ...rest }: DangerConfirmProps): react.JSX.Element;
+
 /**
  * A button that opens the file picker — the shape all three apps kept writing by hand
  * as a `<Button>` plus a hidden `<input type="file">` plus a ref between them (seven
@@ -1361,6 +1796,22 @@ interface FileButtonProps extends Omit<UseFilePickerOptions, "disabled">, Omit<B
      * file leaves it as it was. Off by default, so the button's layout is unchanged.
      */
     showFileName?: boolean;
+    /**
+     * Why picking is not available — {@link Button}'s `disabledReason`, with the picker's
+     * half added (keksdose K3): the button is `aria-disabled` but stays focusable, the
+     * reason is in the kit Tooltip and its description, a click opens no picker, and a
+     * `droppable` button takes no drop (the drag is still cancelled, so the browser does
+     * not navigate to the file). Wins over `disabled`, as on Button.
+     */
+    disabledReason?: ReactNode;
+    /**
+     * This pick COMMITS — an upload that starts on pick, an attachment saved at once.
+     * Under a locked {@link WriteLockProvider} it takes the `disabledReason` path with
+     * the lock's reason (which wins over one of its own). No provider, or an unlocked
+     * one: no effect. A picker that only fills a form the user saves later is not a
+     * commit, and is left live — the form's Save carries the lock.
+     */
+    commit?: boolean;
 }
 /**
  * {@link useFilePicker} behind a {@link Button}: `variant` and every other button prop
@@ -1376,6 +1827,471 @@ interface FileButtonProps extends Omit<UseFilePickerOptions, "disabled">, Omit<B
  */
 declare const FileButton: react.ForwardRefExoticComponent<FileButtonProps & react.RefAttributes<HTMLButtonElement>>;
 
+/**
+ * The conversation under a report: who said what, when, with what attached — and the
+ * box to answer in.
+ *
+ * Both apps had written it by hand. kastlan's feedback page grew a comment list of
+ * bordered boxes with `slate-*` literals (feedback-page.tsx, "keksdose left this
+ * unbuilt"), and keksdose built the same thing a second time for support
+ * (support-thread.tsx) with sides, bubbles and a composer that clears only what it
+ * sent. This is that second one, generalised: the kit owns the look and the
+ * behaviour, the app owns the data, the upload and every word it does not share.
+ *
+ * **Own vs other** is the caller's per message (`own`), not a comparison the kit makes
+ * against a user id: whose message sits at the END side depends on who is reading,
+ * and only the app knows that (keksdose's support thread labelled a member's question
+ * "Du" in the admin panel the first time round, by reading the wrong field).
+ *
+ * **Redaction.** A thread is somebody's words about their own data — exactly what a
+ * host's demo / screen-share mode blurs. Bodies, authors and attachments carry
+ * `data-private` (the attribute `Tooltip redact` and `StatTile sensitive` use) unless
+ * `redact={false}`.
+ *
+ * **RTL.** Sides are logical — `justify-end` is the reading end, and the bubble's
+ * tucked corner is `rounded-ee` / `rounded-es` — and each body is `dir="auto"`, so a
+ * Hebrew reply in an English thread (or the reverse) lays out as its own language.
+ *
+ * **A chat, too** (keksdose G4/G5). keksdose's support chat is the same conversation
+ * read the chat way: status lines between the messages ("Closed automatically",
+ * "Reopened"), a day line where the date changes, clock times under it, Enter to send
+ * and several files uploaded ahead of the send. Each of those is an opt-in here
+ * (`kind: "event"`, `daySeparators`, `timeFormat="clock"`, `sendOn="enter"`,
+ * `attachmentSlot` + `canSend`), so the feedback thread's defaults stay as they were.
+ */
+/** The `feedbackThread` namespace of `<UiKitProvider labels>`. */
+interface FeedbackThreadLabels {
+    /** Accessible name of the message list. */
+    thread: string;
+    empty: string;
+    loading: string;
+    /** Author line of an `own` message that has no `author` of its own. */
+    you: string;
+    /** The badge beside a `staff` author. */
+    staff: string;
+    /** Accessible name of a message's attachment list. */
+    attachments: string;
+}
+declare const DEFAULT_FEEDBACK_THREAD_LABELS: FeedbackThreadLabels;
+/** The `feedbackComposer` namespace of `<UiKitProvider labels>`. The attach buttons'
+ *  words are `feedbackAttachment`'s, shared with the dialog and the note editor. */
+interface FeedbackComposerLabels {
+    /** Accessible name of the text box. */
+    field: string;
+    placeholder: string;
+    send: string;
+    /** The shortcut line, given the platform's modifier ("Ctrl" or "⌘"). */
+    sendHint: (modifier: string) => string;
+    /** The shortcut line under `sendOn="enter"` (keksdose G5): Enter sends, so say how a
+     *  new line is made. */
+    sendHintEnter: string;
+}
+declare const DEFAULT_FEEDBACK_COMPOSER_LABELS: FeedbackComposerLabels;
+interface FeedbackThreadAttachment {
+    id?: string | number;
+    name: string;
+    /** Where to open it. Left out, the attachment is listed by name only. */
+    url?: string;
+    /** MIME type; an `image/*` with a `url` is shown as a thumbnail. */
+    type?: string;
+    /** Bytes, shown beside a non-image. */
+    size?: number;
+}
+interface FeedbackThreadMessage {
+    /** Leave out, or `"message"`. `"event"` is a {@link FeedbackThreadEvent}. */
+    kind?: "message";
+    id: string | number;
+    /** Who wrote it. Left out on an `own` message, it reads "You". */
+    author?: ReactNode;
+    /** A `Date`, an ISO string or epoch ms. */
+    createdAt: Date | string | number;
+    body: string;
+    attachments?: readonly FeedbackThreadAttachment[];
+    /** Written by whoever is reading: sits at the end side, in the brand tint. */
+    own?: boolean;
+    /** Written by the team rather than a user: gets the "Staff" badge. */
+    staff?: boolean;
+}
+/**
+ * A line in the thread that nobody wrote — "Closed automatically", "Marked as
+ * resolved", "Reopened" — drawn centred and muted with its time, no author, no side,
+ * no bubble.
+ *
+ * keksdose G4: its support chat interleaves these with the messages, and as a message
+ * they came out as a bubble from nobody at the start side, which reads as the member
+ * having said "resolved". Word it for the READER, as with `own`: the app knows whether
+ * "you reopened it" or "Anna reopened it" is true for the person looking.
+ *
+ * The text is the app's, not somebody's words about their data, so it is NOT tagged
+ * `data-private`; one that names a person can wrap the name in its own
+ * `<span data-private>` (`body` is a node for that reason).
+ */
+interface FeedbackThreadEvent {
+    kind: "event";
+    id: string | number;
+    /** A `Date`, an ISO string or epoch ms. */
+    createdAt: Date | string | number;
+    body: ReactNode;
+}
+/** One row of a {@link FeedbackThread}: a message, or an event line between them. */
+type FeedbackThreadItem = FeedbackThreadMessage | FeedbackThreadEvent;
+interface FeedbackThreadProps {
+    /** Oldest first. Event lines ({@link FeedbackThreadEvent}) sit among the messages. */
+    messages: readonly FeedbackThreadItem[];
+    loading?: boolean;
+    /** Replaces the default "No comments yet". */
+    empty?: ReactNode;
+    /**
+     * Draw one attachment yourself — for files behind auth, which a plain `<img src>`
+     * cannot fetch (kastlan's `AuthedImage`), or a lightbox. The default is a thumbnail
+     * link for an image with a `url`, a file link otherwise.
+     */
+    renderAttachment?: (attachment: FeedbackThreadAttachment, message: FeedbackThreadMessage) => ReactNode;
+    /** Tag bodies, authors and attachments `data-private`. Default true. */
+    redact?: boolean;
+    /**
+     * How a row's time reads. `"relative"` (default): "5 minutes ago", a date past six
+     * days — right for a report's comments, read days apart. `"clock"`: the time of day
+     * in the locale ("14:05", "2:05 PM") — the chat look, keksdose G4; pair it with
+     * `daySeparators`, which say which day that clock time is on. Either way the full
+     * date and time is in the Tooltip.
+     */
+    timeFormat?: "relative" | "clock";
+    /**
+     * A centred day line before the first row and wherever the next row is on another
+     * calendar day (the device's zone): "Today", "Yesterday", else the date — keksdose
+     * G4. "Today" / "Yesterday" are `Intl.RelativeTimeFormat`'s own words in the kit
+     * locale, so there is no label to translate. Default false.
+     */
+    daySeparators?: boolean;
+    /** "Now" for the relative times and the day lines — pin it in tests and stories.
+     *  Default: the clock. */
+    now?: Date | number;
+    /** Overrides the provider's locale for the times. */
+    locale?: string;
+    labels?: Partial<FeedbackThreadLabels>;
+    className?: string;
+}
+declare function FeedbackThread({ messages, loading, empty, renderAttachment, redact, now, locale: localeProp, timeFormat, daySeparators, labels: labelsProp, className, }: FeedbackThreadProps): react.JSX.Element;
+/** What the composer's attach control takes — {@link FeedbackNoteAttachment} with the
+ *  labels optional, since the field reads `feedbackAttachment` from the provider, and
+ *  `onError` the field's own (0.23.0): it is handed the refused file and the limit too
+ *  (`FeedbackAttachmentErrorInfo`), and a `(kind) => …` handler still fits. */
+type FeedbackComposerAttachment = Omit<FeedbackNoteAttachment, "labels" | "onError"> & {
+    labels?: Partial<FeedbackAttachmentLabels>;
+    onError?: FeedbackAttachmentFieldSingleProps["onError"];
+};
+interface FeedbackComposerProps {
+    /**
+     * Send the comment. Return the promise: the box clears when it RESOLVES, and only of
+     * what was sent — text typed while it was in flight stays. A rejection keeps
+     * everything for a retry (surface the error yourself; the composer stays quiet).
+     *
+     * `attachment` is the built-in field's one picture. Files the host uploaded ahead
+     * (`attachmentSlot`) are the host's state, read by the host here — and `body` may be
+     * `""` when `canSend` let an attachments-only message go.
+     */
+    onSend: (body: string, attachment: File | null) => void | Promise<unknown>;
+    /** The send is in flight: a spinner on the button and no second send. */
+    pending?: boolean;
+    /** Offer one picture with the comment (file, paste or `onCaptureScreenshot`).
+     *  `true` for the defaults. Left out, the composer is text only. */
+    attachment?: boolean | FeedbackComposerAttachment;
+    /**
+     * The host's own attach control, in the row with Send where the built-in field sits
+     * (after it, if both are on) — keksdose G5: its support chat uploads up to N files
+     * AHEAD of the send and sends their refs, which one `File` in `onSend` cannot carry.
+     * The slot is the host's picker plus the chips of what is uploaded; the upload, the
+     * refs and clearing them once `onSend` resolves stay with the host. Pair it with
+     * `canSend`.
+     */
+    attachmentSlot?: ReactNode;
+    /**
+     * Whether Send is enabled, over the composer's own rule (some text in the box) —
+     * for state the composer cannot see, i.e. `attachmentSlot`'s (keksdose G5): `true`
+     * with files ready makes an empty draft sendable (`onSend("", null)`), `false` while
+     * an upload is still running holds even a written reply back. Left out, the text
+     * decides. `pending` blocks a send either way, as does a draft past `maxLength`.
+     */
+    canSend?: boolean;
+    /**
+     * Which key sends. `"mod-enter"` (default): Ctrl/⌘+Enter, the report dialog's and
+     * note editor's shortcut, with plain Enter a new line — feedback is written in
+     * paragraphs. `"enter"`: the chat way (keksdose G5) — Enter sends, Shift+Enter is a
+     * new line, Ctrl/⌘+Enter still sends; an Enter that confirms an IME composition
+     * (Japanese, Chinese input) is the IME's, never a send.
+     */
+    sendOn?: "mod-enter" | "enter";
+    /** Rendered INSTEAD of the composer — the thread is closed, or read-only for this
+     *  reader. */
+    disabledReason?: ReactNode;
+    rows?: number;
+    /**
+     * The longest draft the box takes, in UTF-16 code units as the browser counts — the
+     * server's limit, so a reply too long for it is cut off while it is typed rather than
+     * refused by a 422 after the press (keksdose G6: its support replies are capped at
+     * 4,000 on the server, and its other text fields already count against that with
+     * Textarea's `maxLength` + `showCount` since 0.22; the reply box, a composer, could
+     * not). The box's own `maxLength`, so typing and pasting stop at it.
+     *
+     * {@link FeedbackComposerHandle.insertText} is not stopped by it — the browser limits
+     * typing, not a script — and a canned reply is not cut mid-sentence to fit. A draft
+     * past the limit therefore holds Send back (whatever `canSend` says, as `pending`
+     * does) until it is trimmed; with `showCount` the counter, red at the limit, says by
+     * how much.
+     */
+    maxLength?: number;
+    /**
+     * A live "12/4000" under the box, with `maxLength` — Textarea's `showCount`, the same
+     * counter (keksdose G6): the count is part of the box's description, read with it on
+     * focus, and a polite live region speaks only on entering the last stretch and at the
+     * limit, never per keystroke. Under `size="sm"` the hidden send hint stays the box's
+     * description too, before the count. Ignored without `maxLength`.
+     */
+    showCount?: boolean;
+    /** The counter's words — the `characterCount` namespace, as on Textarea. */
+    countLabels?: Partial<CharacterCountLabels>;
+    /**
+     * The box's hint, over the `placeholder` label — keksdose F9: an admin answering a
+     * support ticket is asked something else ("Reply to Anna…") than a member adding to
+     * their own report, and one provider-wide label cannot say both.
+     */
+    placeholder?: string;
+    /**
+     * The draft, controlled — for a host that keeps it itself (saves it per ticket,
+     * prefills a template). Left out, the composer keeps its own. Either way a send
+     * that resolves clears only what was sent: controlled, that is an
+     * `onValueChange("")` the host receives like any keystroke, and only if the draft
+     * is still the one that went out.
+     */
+    value?: string;
+    /** Every change to the draft — typing, {@link FeedbackComposerHandle.insertText}, the
+     *  clear after a send. Required to change a controlled `value`. */
+    onValueChange?: (value: string) => void;
+    /** {@link FeedbackComposerHandle}: put text into the draft from outside (canned-reply
+     *  chips) or focus the box. */
+    ref?: Ref<FeedbackComposerHandle>;
+    labels?: Partial<FeedbackComposerLabels>;
+    className?: string;
+    /**
+     * `"sm"` for a narrow host — keksdose's assistant launcher, a small floating panel
+     * (0.22): a small Send button, and the send hint ("Enter to send, Shift + Enter for a
+     * new line") hidden from view but kept as the box's description, so a keyboard or
+     * screen-reader user still learns the shortcut. Default `"md"`.
+     */
+    size?: "md" | "sm";
+    /**
+     * On the composer's root — the box, or the `disabledReason` line in its place —
+     * with any `data-*` attribute beside it (keksdose K17). keksdose's assistant tour
+     * points at the chat box with `[data-tour="assistant-ask"]`, and a composer that
+     * dropped every attribute it was not told about left the anchor nowhere: the
+     * assistant kept its hand-built box rather than lose the tour step.
+     */
+    id?: string;
+    /** `data-*` attributes for the root, as `id` — a tour anchor, a test id. */
+    [dataAttribute: `data-${string}`]: string | number | boolean | undefined;
+}
+/**
+ * What a {@link FeedbackComposer} `ref` holds.
+ *
+ * keksdose F9: the support admin answers the same five questions all day and wants
+ * chips above the box ("Thanks, fixed in the next release") that drop their text in
+ * where the caret is. A controlled `value` alone cannot do that well — the host sees
+ * the string, not the caret, so it could only append — so the composer, which owns
+ * the textarea, does the splice.
+ */
+interface FeedbackComposerHandle {
+    /**
+     * Insert `text` at the caret, replacing any selection (the caret the box last had:
+     * a click on a chip blurs it, and the selection survives the blur), then focus the
+     * box with the caret after the inserted text so the reply can go on. Nothing is
+     * added around it — put a space or a newline in `text` if the reply needs one. A
+     * no-op while `disabledReason` replaces the box.
+     */
+    insertText: (text: string) => void;
+    focus: () => void;
+}
+/**
+ * The answer box under a {@link FeedbackThread}: a textarea, an optional picture,
+ * and Send — Ctrl/⌘+Enter sends, the shortcut the report dialog and the note editor
+ * use, so the habit carries across the feature. Plain Enter is a new line: feedback is
+ * written in paragraphs, unlike a chat — which `sendOn="enter"` is for (keksdose G5).
+ */
+declare function FeedbackComposer({ onSend, pending, attachment, attachmentSlot, canSend: canSendProp, sendOn, disabledReason, rows, maxLength, showCount, countLabels, placeholder, value, onValueChange, ref, labels: labelsProp, className, id, size, ...rest }: FeedbackComposerProps): react.JSX.Element;
+/**
+ * {@link FeedbackComposer} under a name that is not about feedback (keksdose K17).
+ *
+ * The component was never feedback-specific: a textarea, an optional picture or a
+ * host's upload slot, Send, `sendOn="enter"` for the chat way. keksdose's assistant
+ * and support chat are chats, not reports, and an import of `FeedbackComposer` there
+ * reads as a mistake to the next person. The same function, not a wrapper, so the
+ * two names cannot drift.
+ */
+declare const ChatComposer: typeof FeedbackComposer;
+/** {@link FeedbackComposerProps}, for {@link ChatComposer}. */
+type ChatComposerProps = FeedbackComposerProps;
+/** {@link FeedbackComposerHandle}, for {@link ChatComposer}. */
+type ChatComposerHandle = FeedbackComposerHandle;
+/** {@link FeedbackComposerLabels}, for {@link ChatComposer} — still the `feedbackComposer`
+ *  namespace of the provider. */
+type ChatComposerLabels = FeedbackComposerLabels;
+
+/**
+ * The `confirmDialog` namespace of `<UiKitProvider labels>`: the two buttons' fallback
+ * text. A call that knows what it is confirming says so per call (`confirmLabel:
+ * "Delete budget"`), which is what the dialog is for — these are for the rest.
+ */
+interface ConfirmDialogLabels {
+    confirm: string;
+    cancel: string;
+    /**
+     * 0.18: label of the field a `requireTyped` confirm shows. A FUNCTION of the text to
+     * type by default — where the address sits in the sentence moves with the language —
+     * or a finished STRING. A call's own `typedLabel` wins over it.
+     *
+     * Required, like every key of a namespace: the shipped catalogues
+     * (`@eifi1/ui-kit/i18n/<code>`) translate it, and an app's own full catalogue should
+     * hear about the new string from the compiler rather than show it in English.
+     */
+    typed: string | ((text: string) => string);
+}
+/** `satisfies` rather than a type annotation, so `.typed` stays known-callable for a
+ *  caller composing its own label from it. */
+declare const DEFAULT_CONFIRM_DIALOG_LABELS: {
+    confirm: string;
+    cancel: string;
+    typed: (text: string) => string;
+};
+type ConfirmTone = "danger" | "warning" | "neutral";
+interface ConfirmOptions {
+    /** The question, and the dialog's accessible name. */
+    title: ReactNode;
+    /** The smaller line under it — the consequence. Wired to `aria-describedby`. */
+    body?: ReactNode;
+    /** Default: `confirmDialog.confirm` from the provider, else "Confirm". */
+    confirmLabel?: ReactNode;
+    /** Default: `confirmDialog.cancel` from the provider, else "Cancel". */
+    cancelLabel?: ReactNode;
+    /**
+     * `"danger"` for what cannot be undone (a delete): the confirm is the destructive
+     * button and focus starts on CANCEL. `"warning"` and `"neutral"` (default) start on
+     * the confirm. See {@link ConfirmProvider} for why the two differ.
+     */
+    tone?: ConfirmTone;
+    /**
+     * 0.18: make the user TYPE this before confirm is enabled — the target account's
+     * e-mail address, a budget's name. For the action whose risk is not "did you mean
+     * it" but "is this the right row": an admin who deactivates somebody has already
+     * proven who THEY are (they passed the admin gate); typing the address is what
+     * proves they read which account they are on. Both keksdose (`TYPE_EMAIL`) and
+     * Kurvenschmiede (`TypedConfirm`) built this beside `useConfirm` because it had no
+     * field.
+     *
+     * The dialog then shows one text field under the body and focuses it (whatever the
+     * tone: a reflexive Enter cannot confirm a field that does not match yet). Confirm
+     * stays disabled until the text matches; Enter in the field confirms once it does.
+     * The answer is still `true` / `false` — the text matched what you passed, so send
+     * that to the server if it asks for the address too, not the user's spelling.
+     */
+    requireTyped?: string;
+    /** Label of that field. Default: `confirmDialog.typed` — `Type “a@b.c” to confirm`. */
+    typedLabel?: string;
+    /**
+     * How the typed text is compared. Default `"caseless"`: surrounding spaces and case
+     * ignored, the rule both apps applied to an address. `"trim"` keeps case, `"exact"`
+     * keeps spaces too — for a phrase like "DELETE" whose contract is "exactly this".
+     */
+    typedMatch?: TypedMatch;
+}
+type ConfirmFn = (options: ConfirmOptions) => Promise<boolean>;
+/**
+ * `const confirm = useConfirm()` → `if (!(await confirm({ title }))) return`.
+ *
+ * The returned function is STABLE for the life of the provider, so it can sit in an
+ * effect's or a `useCallback`'s dependency list without re-running it.
+ *
+ * Throws outside a {@link ConfirmProvider}, rather than falling back to
+ * `window.confirm`: a silent fallback is exactly the native dialog the three apps are
+ * migrating away from, and it would look like the migration had worked.
+ */
+declare function useConfirm(): ConfirmFn;
+interface ConfirmProviderProps {
+    children: ReactNode;
+}
+/**
+ * The host for {@link useConfirm}: ONE confirm dialog for the whole app, rendered on
+ * {@link DialogFrame}, answering a promise.
+ *
+ * Asked for by all three apps at once — keksdose has 20+ `window.confirm` calls,
+ * kastlan 7, lenkbank 1. The native dialog cannot be translated past its OK/Cancel
+ * (those are the BROWSER's language, not the app's), cannot say which button is the
+ * destructive one, and on an installed PWA it prints the origin over the question.
+ * A promise is what lets each of those call sites change by one `await`:
+ *
+ *     if (!window.confirm(t("budget.delete_confirm"))) return;
+ *     // becomes
+ *     if (!(await confirm({ title: t("budget.delete_confirm"), tone: "danger" }))) return;
+ *
+ * ## Its own provider, not part of `UiKitProvider`
+ *
+ * `UiKitProvider` renders nothing: it is strings and a locale, it is optional, and it
+ * NESTS (an inner one re-labels one table). A dialog host inside it would mount a host
+ * per nested provider, and a component under the inner one would open a second dialog
+ * layer of its own. So the host is its own component, mounted once — inside the
+ * `UiKitProvider` whose strings it should speak, which is also the order the labels
+ * need.
+ *
+ * ## Focus
+ *
+ * On CANCEL for `tone: "danger"`, on CONFIRM otherwise. A confirm is often answered by
+ * a reflexive Enter — the key that pressed the Delete button in the first place may
+ * still be down — and for an action that cannot be undone that reflex must land on the
+ * harmless answer; `DangerConfirm` makes the same call ("never to the destructive
+ * button itself"). For everything else the confirm is the expected answer and Enter
+ * accepting it is what `window.confirm` taught users, which the migrating call sites'
+ * users already rely on. Focus returns to whatever opened it, through `Modal`'s trap.
+ *
+ * ## Escape, the backdrop, Back and Cancel all answer `false`
+ *
+ * Only the confirm button answers `true`. Anything that merely dismisses is a no.
+ *
+ * ## A second `confirm` while one is open QUEUES
+ *
+ * It is shown when the first is answered, and each call gets its own answer. The
+ * alternative — answering the open one `false` to make room — would answer a question
+ * the user never answered: a background prompt ("your session is about to expire")
+ * would cancel the delete they were reading. `false` has to mean "the user said no".
+ * A double-click cannot queue two of the same: the first click opens the modal
+ * synchronously (a discrete event's update is flushed before the next one), so the
+ * second lands on the open dialog rather than on the button — at worst on its
+ * backdrop, which answers `false`, the safe way to be wrong.
+ *
+ * Unmounting the provider answers everything still pending `false`, so no caller's
+ * `await` hangs forever.
+ *
+ * ## keksdose's synchronous call (transaction-swipe-plan.ts)
+ *
+ * `buildTxSwipeActions` is synchronous, but its `window.confirm` sits inside the
+ * action THUNK (`confirmed(key, run)` returns `() => { if (confirm(…)) run() }`), and a
+ * thunk may be async without its caller knowing. So the plan builder stays
+ * synchronous; it takes the confirm as an argument and the thunk awaits it:
+ *
+ *     // mobile-transaction-list.tsx
+ *     const confirm = useConfirm();
+ *     buildTxSwipeActions({ tx, …, confirm });
+ *
+ *     // transaction-swipe-plan.ts
+ *     const confirmed = (messageKey: string, run: () => void) => () => {
+ *       void confirm({ title: t(messageKey), tone: "danger" }).then((ok) => ok && run());
+ *     };
+ *
+ * Its test then passes `confirm: vi.fn(async () => false)` instead of stubbing the
+ * global, and asserts after an `await` (the mutation now runs a microtask later). The
+ * row snaps back when the swipe commits, before the answer — which is right: the
+ * dialog, not the half-swiped row, is where the question now is.
+ */
+declare function ConfirmProvider({ children }: ConfirmProviderProps): react.JSX.Element;
+
 /** The words a copy button says. The visible three are short on purpose (they
  *  replace the button's own text in the `label` variant); the two announcements
  *  are the sentences a screen reader hears, since the button's focus never moves. */
@@ -1445,8 +2361,17 @@ declare function CopyButton({ text, variant, label, buttonVariant, size, tone, s
 interface FormActionsLabels {
     save: string;
     cancel: string;
+    /**
+     * The {@link FormActionsProps.submitShortcut} hint beside Save's text, when
+     * {@link FormActionsProps.submitShortcutHint} shows it. `apple` is true on a Mac,
+     * iPhone or iPad, where the key is Cmd: "⌘ Enter" there, "Ctrl+Enter" elsewhere
+     * (a German keyboard says "Strg").
+     */
+    submitShortcut: (apple: boolean) => string;
 }
 declare const DEFAULT_FORM_ACTIONS_LABELS: FormActionsLabels;
+/** See {@link FormActionsProps.submitShortcut}. */
+type FormActionsSubmitShortcut = "mod-enter";
 type FormActionsAlign = "start" | "center" | "end" | "between";
 /**
  * Where the row sits:
@@ -1550,6 +2475,27 @@ interface FormActionsProps extends Omit<ComponentPropsWithoutRef<"div">, "childr
     /** The save button's variant. Default `brand`; `danger` for a save that destroys
      *  (kastlan's `destructive` flag on its own FormActions). */
     submitVariant?: ButtonVariant;
+    /**
+     * The Cancel button's variant. Default `secondary` (the outlined button, as before).
+     * `ghost` for a row where Cancel should step back further than an outline — keksdose
+     * G3: a quiet inline row (a confirm under a table row, a card's own small editor)
+     * whose Cancel was a ghost button before it moved onto FormActions, which drew every
+     * Cancel outlined.
+     */
+    cancelVariant?: ButtonVariant;
+    /**
+     * The size of every button the row draws itself — Save, Cancel and the
+     * `{ label, onClick }` form of {@link destructive}: Button's `size`. Default `md`.
+     * `sm` (12px text, `px-2 py-1`) for a dense row: a confirm inside a table's expansion
+     * row, a toolbar card. keksdose G3: two such rows had small hand-built buttons and lost
+     * them on adopting FormActions, which had no size. At `sm` the spinner and
+     * {@link submitIcon} shrink with the text.
+     *
+     * Your own elements (`children`, an element passed as `destructive`, `start`) are
+     * yours to size — pass them `size="sm"` too. A `size` in {@link submitProps} still
+     * wins for Save, as it always has.
+     */
+    size?: ButtonSize;
     /**
      * A destructive action at the START of the row, apart from Save and Cancel — the
      * "Delete" of an edit dialog. Pass `{ label, onClick }` for the kit's quiet danger
@@ -1606,6 +2552,39 @@ interface FormActionsProps extends Omit<ComponentPropsWithoutRef<"div">, "childr
     /** The `id` of the `<form>` the save button submits, when the row is rendered
      *  outside it (a dialog's footer slot). */
     form?: string;
+    /**
+     * A keyboard shortcut that presses Save from anywhere in the form. `"mod-enter"`:
+     * Ctrl+Enter, or Cmd+Enter on a Mac — both are accepted everywhere, as keksdose's
+     * editors always have. keksdose K14 (inputs audit 2026-10-02, S5): its transaction
+     * editor, category editor and create card each wrote this as an `onKeyDown` on a
+     * container, re-stating `!pending && !saveDisabled && !lock.locked` every time, and
+     * the one that forgot the lock let the demo's refused save through from the keyboard.
+     *
+     * What it does is what pressing Save does — the same button is clicked, so a form
+     * submits with its validation and its submitter, and `onSubmit` is called in the
+     * `type="button"` mode — and it does NOTHING while Save could not be pressed:
+     * `pending`, `submitDisabled`, or a `commit` under a locked {@link WriteLockProvider}.
+     *
+     * Scoped to the form Save submits (the `form` prop's, else the enclosing `<form>`):
+     * the chord counts only when the focus is inside it, so two editors on one page each
+     * answer for their own fields. Without a form (an `onSubmit` row in a plain container)
+     * the scope is the nearest `role="dialog"`, else the row's parent element — the
+     * container the row ends.
+     *
+     * Listened for on the document, so it runs AFTER every React handler: a field that
+     * takes Ctrl+Enter for itself calls `preventDefault()` or `stopPropagation()` and
+     * the row stays out of it (keksdose live #202 — the create card's Ctrl+Shift+Enter
+     * must create ONE row; the chord here is exactly Ctrl/Cmd+Enter, never with Shift or
+     * Alt). Not during IME composition, and not on a held key's repeats.
+     *
+     * The save button announces it with `aria-keyshortcuts`; {@link submitShortcutHint}
+     * also shows it.
+     */
+    submitShortcut?: FormActionsSubmitShortcut;
+    /** Show the {@link submitShortcut} beside Save's text ("Ctrl+Enter", "⌘ Enter"; the
+     *  `form.submitShortcut` label), dimmed. Hidden on a touch-only device, which has no
+     *  keyboard to press it on. Default `false`. */
+    submitShortcutHint?: boolean;
     /** Extra actions, placed before Cancel. */
     children?: ReactNode;
 }
@@ -1624,7 +2603,7 @@ interface FormActionsProps extends Omit<ComponentPropsWithoutRef<"div">, "childr
  * The spinner is the kit's {@link Spinner}, drawn inside the button with `label={null}`
  * so the button's name stays its text; `aria-busy` is what says it is working.
  */
-declare function FormActions({ onCancel, onSubmit, submitLabel, cancelLabel, pendingLabel, submitIcon: SubmitIcon, submitProps, pending, submitDisabled, submitDisabledReason, commit, submitVariant, destructive, start: startSlot, align, placement: placementProp, stickyWithin, bleed, form, children, className, style, ...rest }: FormActionsProps): react.JSX.Element;
+declare function FormActions({ onCancel, onSubmit, submitLabel, cancelLabel, pendingLabel, submitIcon: SubmitIcon, submitProps, pending, submitDisabled, submitDisabledReason, commit, submitVariant, cancelVariant, size, destructive, start: startSlot, align, placement: placementProp, stickyWithin, bleed, form, submitShortcut, submitShortcutHint, children, className, style, ...rest }: FormActionsProps): react.JSX.Element;
 
 /**
  * Who holds one record, and the owner's every way of changing that — Kurvenschmiede's
@@ -1806,6 +2785,147 @@ interface ShareDialogProps extends SharePanelProps, Pick<DialogFrameProps, "open
  */
 declare function ShareDialog({ open, onClose, size, className, title, description, ...panel }: ShareDialogProps): react.JSX.Element;
 
+/** The messages {@link IbanInput} shows under itself, one per {@link IbanProblem}. */
+interface IbanInputLabels {
+    /** The value does not start with a two-letter country code and two check digits. */
+    format: string;
+    /** The first two letters are no country in the IBAN registry. `code` is those two
+     *  letters, as typed (upper case). */
+    country: (code: string) => string;
+    /** The wrong length for the country: `actual` characters typed, `expected` for that
+     *  country (spaces not counted in either). */
+    length: (actual: number, expected: number) => string;
+    /** The mod-97 check digits do not match — a mistyped or swapped character. */
+    checksum: string;
+    /** `kind="qr"`: a valid IBAN, but not a QR-IBAN. */
+    qrRequired: string;
+    /** `kind="plain"`: a QR-IBAN, which cannot receive an ordinary transfer. */
+    qrNotAllowed: string;
+}
+declare const DEFAULT_IBAN_INPUT_LABELS: IbanInputLabels;
+interface IbanInputProps extends Omit<InputProps, "type" | "value" | "defaultValue"> {
+    /** The IBAN, compact or not — it is shown in groups of four either way. `""` is
+     *  "no IBAN". */
+    value: string;
+    /** The compact, upper-case IBAN (the electronic format, what to store) on every
+     *  change — valid or not: a half-typed IBAN is still the field's value. Plain
+     *  `onChange` still fires alongside it with the raw event, whose text is the GROUPED
+     *  one, so bind this rather than `onChange` to a form. */
+    onValueChange?: (value: string) => void;
+    /** Which IBANs the field accepts. Default `"any"`. `"qr"` / `"plain"`: see
+     *  {@link IbanKind} — and why the difference matters, {@link isQrIban}. */
+    kind?: IbanKind;
+    /** The messages, per field. See {@link IbanInputLabels}. */
+    labels?: Partial<IbanInputLabels>;
+    /** The caller's own message, shown INSTEAD of the built-in one while it is set (a
+     *  server's "this account is already on file"). `null`, `false` and `""` are no
+     *  message, so `touched && errors.iban` can be passed as it is. */
+    error?: ReactNode;
+}
+/**
+ * An IBAN field (kastlan, keksdose): typed in any shape, shown in groups of four,
+ * reported compact.
+ *
+ * Both apps had a text field and a regex. What that left out is everything between
+ * the keyboard and the stored value: a pasted "ch09 0000-0000…" stayed lower case
+ * with its hyphens, the grouping that makes 21 characters checkable by eye was
+ * missing, and a wrong IBAN was found out by the bank. Here:
+ *
+ *  - **Grouped as you type.** The field shows the paper format ({@link formatIban});
+ *    spaces, hyphens and lower case in what is typed or pasted are folded away, and
+ *    the caret stays between the same two characters while the groups move around it.
+ *  - **Compact out.** `onValueChange` gets the electronic format — upper case, no
+ *    spaces — which is the one to store and to compare.
+ *  - **Checked, never blocked.** A wrong country, length or checksum shows a message
+ *    under the field, through the kit's `error` (so it is the field's
+ *    `aria-describedby` and paints it), but every keystroke still lands: a field that
+ *    refuses characters cannot be corrected one character at a time. While the field
+ *    has focus only what more typing cannot fix is shown; the rest waits for the full
+ *    length or for blur. Whether the field is REQUIRED stays the form's rule — an empty
+ *    field says nothing.
+ *  - **QR-IBAN or not** (kastlan): `kind="qr"` refuses a regular IBAN and
+ *    `kind="plain"` refuses a QR-IBAN — a QR-bill can only be paid to a QR-IBAN, and a
+ *    QR-IBAN can receive nothing else. See {@link isQrIban}.
+ *
+ * It is {@link Input} underneath, so `label`, `hint`, `error`, `invalid` and the rest
+ * are Input's own and the field reads like every other. A form that must not submit
+ * an invalid IBAN checks {@link isValidIban} / {@link ibanProblem} itself — the field
+ * shows the problem but does not own the submit.
+ */
+declare const IbanInput: react.ForwardRefExoticComponent<IbanInputProps & react.RefAttributes<HTMLInputElement>>;
+
+/** The words {@link PhoneInput} renders on its own behalf. */
+interface PhoneInputLabels {
+    /** The country-code select's accessible name. */
+    countryCode: string;
+    /** The select's last option: a number from a country not listed, typed with its
+     *  own "+". */
+    other: string;
+}
+declare const DEFAULT_PHONE_INPUT_LABELS: PhoneInputLabels;
+interface PhoneInputProps extends Omit<InputProps, "type" | "value" | "defaultValue"> {
+    /** The number: E.164 ("+41210000001") for one the field could read, or free text —
+     *  a value saved before the field existed is shown exactly as it is. `""` is no
+     *  number. */
+    value: string;
+    /** On every change: E.164 when the typed text reads as a number of the selected
+     *  country (or carries its own "+"), otherwise the typed text UNCHANGED. Nothing is
+     *  refused — see {@link PhoneInput}. Plain `onChange` still fires with the raw event;
+     *  bind this one to a form. */
+    onValueChange?: (value: string) => void;
+    /** The country a number typed without "+" belongs to, until the value says
+     *  otherwise. Default `"CH"`. */
+    defaultCountry?: PhoneCountry;
+    /** The countries the select offers, in order; "Other" always follows. Default
+     *  {@link PHONE_COUNTRIES} (CH, LI, DE, AT, FR, IT). A stored number from a country
+     *  left out still shows under its own code. */
+    countries?: readonly PhoneCountryCode[];
+    /** See {@link PhoneInputLabels}. */
+    labels?: Partial<PhoneInputLabels>;
+    /** Classes for the whole field — the select, the input and the lines under them.
+     *  `inputClassName` reaches the `<input>`. */
+    className?: string;
+}
+/**
+ * A phone number field (kastlan): a country-code select and the number, stored as
+ * E.164 and shown grouped.
+ *
+ * kastlan's contacts kept whatever was typed — "079 …", "+41 (0)79 …", "0041 79 …" —
+ * which nobody could dial from the app or match against the next import. This field
+ * turns all of those into one stored form, "+41210000001", without taking anything
+ * away from the person typing:
+ *
+ *  - **A country to type against.** The select (default CH, then LI, DE, AT, FR, IT
+ *    and "Other") says which country a number without "+" belongs to; the national
+ *    trunk 0 may be typed or left out. Typing a "+" or "00" overrides it, and the
+ *    select follows the number ("+49 …" switches it to DE). Changing the select moves
+ *    the national number to the new country code.
+ *  - **E.164 when it reads, the text when it does not.** A number the rules read is
+ *    emitted as E.164; anything else ("ask reception", an extension) is emitted exactly
+ *    as typed. Never refused, never an error of its own: a contact's number is often
+ *    known only roughly, and a field that will not save "079 … (mornings)" makes
+ *    people type it into the notes instead. An app that needs a dialable number
+ *    checks {@link isE164} on submit.
+ *  - **Existing values untouched.** A free-text value from before is shown exactly as
+ *    it is, and normalised only when someone edits it — the field never rewrites a
+ *    record just by being opened.
+ *  - **Grouped when settled.** While typing the field shows what was typed; on blur a
+ *    number it read is regrouped by its country ("21 000 00 01").
+ *
+ * **The limitation** — there is no libphonenumber behind this (≈150 kB of metadata in
+ * every bundle): the six countries have light rules (the trunk 0, a plausible length)
+ * and every other country is any "+" with 8–15 digits. A well-formed number that does
+ * not exist passes, and German and Austrian landlines, whose area codes vary in length,
+ * are grouped only where the split is known (mobile prefixes, the largest cities) and
+ * otherwise shown as one block. See `lib/phone.ts`.
+ *
+ * `label`, `hint`, `error` and `invalid` read as on {@link Input}: the label floats in
+ * the number's box, and a text hint and the error go under the whole row, attached to
+ * the number with `aria-describedby`. The select is named by `labels.countryCode`, and
+ * the pair is a group named by a string `label`.
+ */
+declare const PhoneInput: react.ForwardRefExoticComponent<PhoneInputProps & react.RefAttributes<HTMLInputElement>>;
+
 /**
  * EVERY string the kit renders, as one typed tree — and an optional provider that
  * hands it to every component at once.
@@ -2032,6 +3152,21 @@ interface UiKitLabels {
     translationReview: TranslationReviewLabels;
     /** 0.19.0: `LegalLinks`' navigation name — the legal pages' shell, for every app. */
     legal: LegalLabels;
+    /** 0.22.0: the screen-reader words of `Input` / `Textarea`'s `showCount` counter. */
+    characterCount: CharacterCountLabels;
+    /** 0.22.0: `CountrySelect`. Its list's "no results" and counts are `combobox`'s. */
+    countrySelect: CountrySelectLabels;
+    /** 0.22.0: `InlineEditField` — keksdose K9. */
+    inlineEdit: InlineEditLabels;
+    /** 0.22.0: `IbanInput`'s messages, one per problem. */
+    ibanInput: IbanInputLabels;
+    /** 0.22.0: `PhoneInput`'s country-code select. */
+    phoneInput: PhoneInputLabels;
+    /** 0.22.0: `SignChip` — the outflow / inflow toggle beside an amount. */
+    signChip: SignChipLabels;
+    /** 0.23.0: `ColumnMapper` / `ColumnRoleTable` — a pasted or dropped table, a role per
+     *  column. */
+    columnMapper: ColumnMapperLabels;
 }
 /**
  * A label override, as deep as the labels go: an object of labels (a namespace, or a
@@ -2065,6 +3200,35 @@ declare const DEFAULT_FILE_LABELS: FileLabels;
 /** "12 kB", "3.4 MB" — `Intl`'s unit formatting, so the digits, the decimal mark and
  *  the unit's spelling all follow `locale`. */
 declare function formatFileSize(bytes: number, locale?: string): string;
+/** What a {@link KitDateFormatter} is told about the date it is formatting. */
+interface KitDateFormatContext {
+    /**
+     * How much of a date the string is: `"day"` — the `iso` is `"YYYY-MM-DD"`; `"month"` —
+     * `"YYYY-MM"` (a `MonthPicker`); `"year"` — `"YYYY"` (`MonthPicker mode="year"`).
+     */
+    unit: "day" | "month" | "year";
+    /** Which kit surface asks: the trigger of a `DatePicker`, of a `DateRangePicker`
+     *  (called once per end), of a `MonthPicker`, or a `DateMark`. */
+    source: "datePicker" | "dateRangePicker" | "monthPicker" | "dateMark";
+    /** The locale the kit would have formatted in — the component's `locale` prop, else
+     *  the provider's — or `undefined` for the runtime's. */
+    locale: string | undefined;
+    /**
+     * The kit's suggestion: whether this date stands alone where the day of the week
+     * helps — `true` for a `DatePicker`'s trigger and a `DateMark`, `false` for the two
+     * ends of a range (twice the width, in a sentence-like "from – to") and for a month
+     * or a year. keksdose's rule, which this follows: *"A date in a COLUMN carries the
+     * weekday. A date in a SENTENCE does not."* (date-cell.tsx, dev#546). A formatter
+     * is free to ignore it.
+     */
+    weekday: boolean;
+}
+/**
+ * The app's ONE answer to "what does a date look like here" — keksdose K12. Returns the
+ * text for an ISO date (see {@link KitDateFormatContext.unit} for the three shapes).
+ * Return `""` to fall back to the kit's own formatting for that date.
+ */
+type KitDateFormatter = (iso: string, context: KitDateFormatContext) => string;
 /** Where a chart shows the values under the pointer — see `SeriesChartTooltip.placement`. */
 type ChartTooltipPlacement = "cursor" | "above" | "below" | "auto";
 /**
@@ -2127,6 +3291,25 @@ interface UiKitProviderProps {
      * pointer, as before.
      */
     chartTooltipPlacement?: ChartTooltipPlacement;
+    /**
+     * How every kit date below is written, when the component is not told otherwise —
+     * keksdose K12. keksdose has a date-format preference (Settings ▸ date format, feedback
+     * #180) that is not the UI language, and a weekday in the UI language beside digits
+     * in the preference's order (live #246, dev#546): two locales in one string, which
+     * no `locale` + `Intl` options can say. Its `DateField` wraps every `DatePicker` to
+     * pass `formatValue`, and its report range field formats both ends by hand; with this
+     * set once on the provider, those wrappers thin to nothing.
+     *
+     * Used for the trigger text of `DatePicker`, `DateRangePicker` and `MonthPicker`
+     * (month and year mode), and for `DateMark display="date"`. A component's own
+     * `formatValue` or `formatOptions` (`dateStyle` on a DateMark) wins: prop >
+     * provider > the kit's `Intl` default, the order every kit setting resolves in. Left
+     * out (or returning `""`), everything formats exactly as before.
+     *
+     * Keep it stable (`useCallback`, or a module function): it is in the provider's
+     * context value, so a new function every render re-renders every consumer.
+     */
+    formatDate?: KitDateFormatter;
     children: ReactNode;
 }
 /**
@@ -2137,7 +3320,7 @@ interface UiKitProviderProps {
  * it names, so a page can re-label one table's `dataTable.table` without restating
  * the language.
  */
-declare function UiKitProvider({ labels, locale, weekStartsOn, linkComponent, chartTooltipPlacement, children, }: UiKitProviderProps): react.JSX.Element;
+declare function UiKitProvider({ labels, locale, weekStartsOn, linkComponent, chartTooltipPlacement, formatDate, children, }: UiKitProviderProps): react.JSX.Element;
 /** What the nearest provider says about one namespace — `undefined` outside one.
  *  For a component whose own resolver does more than a merge (the data table
  *  derives `columnsCount` from `columns`): feed `{ ...overrides, ...props }` to it. */
@@ -2159,6 +3342,9 @@ declare function useKitLink(): KitLinkComponent | undefined;
 declare function useKitWeekStart(): WeekDay | undefined;
 /** The provider's `chartTooltipPlacement`, or `undefined` — a chart's own prop wins. */
 declare function useKitChartTooltipPlacement(): ChartTooltipPlacement | undefined;
+/** The nearest provider's `formatDate`, or `undefined` — a component's own
+ *  `formatValue` / `formatOptions` wins over it. See {@link KitDateFormatter}. */
+declare function useKitDateFormatter(): KitDateFormatter | undefined;
 /** {@link DEFAULT_FILE_LABELS}, but formatting in the provider's locale. */
 declare function useKitFileLabels(prop?: Partial<FileLabels>): FileLabels;
 /**
@@ -2175,4 +3361,4 @@ declare function useKitFileLabels(prop?: Partial<FileLabels>): FileLabels;
  */
 declare function missingKitLabels(labels: UiKitLabelOverrides | undefined, reference: UiKitLabels): string[];
 
-export { FIELD_BASE as $, type AppShellLabels as A, Button as B, type CalculatorLabels as C, CopyButton as D, type CopyButtonLabels as E, type CopyButtonProps as F, type CurrencyLabels as G, DEFAULT_APP_SHELL_LABELS as H, DEFAULT_CALCULATOR_LABELS as I, DEFAULT_COMBOBOX_LABELS as J, DEFAULT_COMMON_LABELS as K, DEFAULT_COPY_BUTTON_LABELS as L, DEFAULT_CURRENCY_LABELS as M, DEFAULT_DATE_PICKER_LABELS as N, DEFAULT_FILE_LABELS as O, DEFAULT_FILE_PICKER_LABELS as P, DEFAULT_FORM_ACTIONS_LABELS as Q, DEFAULT_MULTI_SELECT_LABELS as R, DEFAULT_PASSWORD_REVEAL_LABELS as S, DEFAULT_PICKER_SHEET_LABELS as T, DEFAULT_SHARE_CARD_LABELS as U, DEFAULT_SWIPEABLE_ROW_LABELS as V, DEFAULT_TABS_LABELS as W, DEFAULT_TOP_BAR_LABELS as X, type DatePickerLabels as Y, EmptyState as Z, type EmptyStateProps as _, type ButtonClassesOptions as a, type SharePendingGrant as a$, FIELD_DISPLAY as a0, FIELD_FLOATING_PAD as a1, FIELD_INVALID as a2, FIELD_TRIGGER as a3, FIELD_WRITABLE_LOOK as a4, FLOATING_INPUT_CLASS as a5, FLOATING_LABEL_CLASS as a6, FLOATING_LABEL_STATIC as a7, FieldChevron as a8, type FieldChevronProps as a9, type IconButtonTone as aA, type IconButtonToneColor as aB, type IconButtonVariant as aC, Input as aD, type InputProps as aE, type KitLinkComponent as aF, type KitLinkProps as aG, Label as aH, type LabelOverride as aI, type LabelProps as aJ, type MultiSelectLabels as aK, PHONE_QUERY as aL, type PasswordRevealLabels as aM, type PickerSheetLabels as aN, type ResponsiveFormActionsPlacement as aO, Select as aP, type SelectProps as aQ, type ShareAddRequest as aR, type ShareCandidate as aS, ShareCard as aT, type ShareCardLabels as aU, type ShareCardProps as aV, ShareDialog as aW, type ShareDialogProps as aX, type ShareGrantee as aY, SharePanel as aZ, type SharePanelProps as a_, FieldHint as aa, type FieldHintProps as ab, FieldLabel as ac, type FieldLabelProps as ad, FileButton as ae, type FileButtonProps as af, type FileLabels as ag, type FilePickerLabels as ah, type FileRejection as ai, type FileRejectionReason as aj, type FileScreenOptions as ak, FloatingField as al, type FloatingFieldProps as am, FormActions as an, type FormActionsAlign as ao, type FormActionsDestructive as ap, type FormActionsLabels as aq, type FormActionsPlacement as ar, type FormActionsProps as as, type FormActionsStickyWithin as at, type FormActionsSubmitProps as au, IconButton as av, type IconButtonGlyphSize as aw, type IconButtonLinkProps as ax, type IconButtonProps as ay, type IconButtonSize as az, type ButtonLinkProps as b, type ShareRole as b0, Spinner as b1, type SpinnerProps as b2, type SwipeableRowLabels as b3, type TabItem as b4, Tabs as b5, type TabsLabels as b6, type TabsProps as b7, Textarea as b8, type TextareaProps as b9, type TopBarLabels as ba, type UiKitLabelOverrides as bb, type UiKitLabels as bc, UiKitProvider as bd, type UiKitProviderProps as be, type UseFilePickerOptions as bf, type UseFilePickerReturn as bg, buttonClasses as bh, formatFileSize as bi, matchesAccept as bj, missingKitLabels as bk, resolvePasswordRevealLabels as bl, useFilePicker as bm, useKitChartTooltipPlacement as bn, useKitFileLabels as bo, useKitLabelOverrides as bp, useKitLabels as bq, useKitLink as br, useKitLocale as bs, useKitWeekStart as bt, type FilePickHandler as bu, formatAccept as bv, judgePick as bw, screenFiles as bx, summariseRejections as by, type ButtonProps as c, type ButtonSize as d, type ButtonTone as e, type ButtonVariant as f, Card as g, CardAction as h, type CardActionProps as i, CardContent as j, type CardContentProps as k, type CardDensity as l, CardDescription as m, type CardDescriptionProps as n, CardFooter as o, type CardFooterProps as p, CardHeader as q, type CardHeaderProps as r, type CardProps as s, CardTitle as t, type CardTitleLevel as u, type CardTitleProps as v, type CardTone as w, type ChartTooltipPlacement as x, type ComboboxLabels as y, type CommonLabels as z };
+export { DEFAULT_COPY_BUTTON_LABELS as $, type AppShellLabels as A, Button as B, type CalculatorLabels as C, type ChatComposerHandle as D, type ChatComposerLabels as E, type ChatComposerProps as F, type ComboboxLabels as G, type CommonLabels as H, type ConfirmDialogLabels as I, type ConfirmFn as J, type ConfirmOptions as K, ConfirmProvider as L, type ConfirmProviderProps as M, type ConfirmTone as N, CopyButton as O, type CopyButtonLabels as P, type CopyButtonProps as Q, type CurrencyLabels as R, CurrentPasswordInput as S, type CurrentPasswordInputLabels as T, type CurrentPasswordInputProps as U, DEFAULT_APP_SHELL_LABELS as V, DEFAULT_CALCULATOR_LABELS as W, DEFAULT_CHARACTER_COUNT_LABELS as X, DEFAULT_COMBOBOX_LABELS as Y, DEFAULT_COMMON_LABELS as Z, DEFAULT_CONFIRM_DIALOG_LABELS as _, type ButtonClassesOptions as a, type FormActionsProps as a$, DEFAULT_CURRENCY_LABELS as a0, DEFAULT_DANGER_CONFIRM_LABELS as a1, DEFAULT_DATE_PICKER_LABELS as a2, DEFAULT_FEEDBACK_COMPOSER_LABELS as a3, DEFAULT_FEEDBACK_THREAD_LABELS as a4, DEFAULT_FILE_LABELS as a5, DEFAULT_FILE_PICKER_LABELS as a6, DEFAULT_FORM_ACTIONS_LABELS as a7, DEFAULT_IBAN_INPUT_LABELS as a8, DEFAULT_MULTI_SELECT_LABELS as a9, type FeedbackComposerLabels as aA, type FeedbackComposerProps as aB, FeedbackThread as aC, type FeedbackThreadAttachment as aD, type FeedbackThreadEvent as aE, type FeedbackThreadItem as aF, type FeedbackThreadLabels as aG, type FeedbackThreadMessage as aH, type FeedbackThreadProps as aI, FieldChevron as aJ, type FieldChevronProps as aK, FieldHint as aL, type FieldHintProps as aM, FileButton as aN, type FileButtonProps as aO, type FileLabels as aP, type FilePickerLabels as aQ, type FileRejection as aR, type FileRejectionReason as aS, type FileScreenOptions as aT, FloatingField as aU, type FloatingFieldProps as aV, FormActions as aW, type FormActionsAlign as aX, type FormActionsDestructive as aY, type FormActionsLabels as aZ, type FormActionsPlacement as a_, DEFAULT_PASSWORD_REVEAL_LABELS as aa, DEFAULT_PHONE_INPUT_LABELS as ab, DEFAULT_PICKER_SHEET_LABELS as ac, DEFAULT_SHARE_CARD_LABELS as ad, DEFAULT_SWIPEABLE_ROW_LABELS as ae, DEFAULT_TABS_LABELS as af, DEFAULT_TOP_BAR_LABELS as ag, DangerConfirm as ah, type DangerConfirmLabels as ai, type DangerConfirmProps as aj, type DangerConfirmValues as ak, type DangerConsequence as al, type DatePickerLabels as am, EmptyState as an, type EmptyStateProps as ao, FIELD_BASE as ap, FIELD_DISPLAY as aq, FIELD_FLOATING_PAD as ar, FIELD_INVALID as as, FIELD_TRIGGER as at, FIELD_WRITABLE_LOOK as au, FLOATING_INPUT_CLASS as av, FLOATING_LABEL_CLASS as aw, FeedbackComposer as ax, type FeedbackComposerAttachment as ay, type FeedbackComposerHandle as az, type ButtonLinkProps as b, type UseFilePickerOptions as b$, type FormActionsStickyWithin as b0, type FormActionsSubmitProps as b1, type FormActionsSubmitShortcut as b2, IbanInput as b3, type IbanInputLabels as b4, type IbanInputProps as b5, IconButton as b6, type IconButtonGlyphSize as b7, type IconButtonLinkProps as b8, type IconButtonProps as b9, type ShareCardLabels as bA, type ShareCardProps as bB, ShareDialog as bC, type ShareDialogProps as bD, type ShareGrantee as bE, SharePanel as bF, type SharePanelProps as bG, type SharePendingGrant as bH, type ShareRole as bI, Spinner as bJ, type SpinnerProps as bK, type SwipeableRowLabels as bL, type TabItem as bM, Tabs as bN, type TabsLabels as bO, type TabsProps as bP, Textarea as bQ, type TextareaProps as bR, type TopBarLabels as bS, TypedConfirmField as bT, type TypedConfirmFieldLabels as bU, type TypedConfirmFieldProps as bV, type TypedMatch as bW, type UiKitLabelOverrides as bX, type UiKitLabels as bY, UiKitProvider as bZ, type UiKitProviderProps as b_, type IconButtonSize as ba, type IconButtonTone as bb, type IconButtonToneColor as bc, type IconButtonVariant as bd, Input as be, type InputProps as bf, type KitDateFormatContext as bg, type KitDateFormatter as bh, type KitLinkComponent as bi, type KitLinkProps as bj, Label as bk, type LabelOverride as bl, type LabelProps as bm, type MultiSelectLabels as bn, PHONE_QUERY as bo, type PasswordRevealLabels as bp, PhoneInput as bq, type PhoneInputLabels as br, type PhoneInputProps as bs, type PickerSheetLabels as bt, type ResponsiveFormActionsPlacement as bu, Select as bv, type SelectProps as bw, type ShareAddRequest as bx, type ShareCandidate as by, ShareCard as bz, type ButtonProps as c, type UseFilePickerReturn as c0, buttonClasses as c1, formatFileSize as c2, matchesAccept as c3, missingKitLabels as c4, resolvePasswordRevealLabels as c5, typedMatches as c6, useConfirm as c7, useFilePicker as c8, useKitChartTooltipPlacement as c9, useKitDateFormatter as ca, useKitFileLabels as cb, useKitLabelOverrides as cc, useKitLabels as cd, useKitLink as ce, useKitLocale as cf, useKitWeekStart as cg, type FilePickHandler as ch, usePromisePending as ci, formatAccept as cj, judgePick as ck, screenFiles as cl, summariseRejections as cm, type ButtonSize as d, type ButtonTone as e, type ButtonVariant as f, Card as g, CardAction as h, type CardActionProps as i, CardContent as j, type CardContentProps as k, type CardDensity as l, CardDescription as m, type CardDescriptionProps as n, CardFooter as o, type CardFooterProps as p, CardHeader as q, type CardHeaderProps as r, type CardProps as s, CardTitle as t, type CardTitleLevel as u, type CardTitleProps as v, type CardTone as w, type CharacterCountLabels as x, type ChartTooltipPlacement as y, ChatComposer as z };