@eifi1/ui-kit 0.20.1 → 0.22.0

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

@@ -1,6 +1,6 @@
 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 { 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';
@@ -19,15 +19,13 @@ 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 { f as FeedbackAttachmentFieldLabels, t as FeedbackDialogTextLabels } from './feedback-attachment-NhUm7Zga.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,11 @@ 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';
 
 type ButtonVariant = "primary" | "secondary" | "ghost" | "danger" | "brand" | "link";
 type ButtonSize = "sm" | "md";
@@ -669,6 +672,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 +718,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 +778,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 +809,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 +1238,317 @@ 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;
+}
+/** `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;
+};
+/**
+ * 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.
+     */
+    onConfirm: (password?: string) => void | Promise<unknown>;
+    /** Show a password field; confirm stays disabled until it is filled. */
+    requirePassword?: boolean;
+    /**
+     * Show an "I understand" checkbox; confirm stays disabled 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 stays disabled 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 stays
+ * disabled until every guard is satisfied.
+ *
+ * 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 +1746,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 +1777,162 @@ interface FileButtonProps extends Omit<UseFilePickerOptions, "disabled">, Omit<B
  */
 declare const FileButton: react.ForwardRefExoticComponent<FileButtonProps & react.RefAttributes<HTMLButtonElement>>;
 
+/**
+ * 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 +2002,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:
@@ -1606,6 +2172,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 +2223,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, 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 +2405,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 +2772,18 @@ 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;
 }
 /**
  * A label override, as deep as the labels go: an object of labels (a namespace, or a
@@ -2065,6 +2817,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 +2908,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 +2937,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 +2959,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 +2978,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_FILE_LABELS as $, type AppShellLabels as A, Button as B, type CalculatorLabels as C, type CommonLabels as D, type ConfirmDialogLabels as E, type ConfirmFn as F, type ConfirmOptions as G, ConfirmProvider as H, type ConfirmProviderProps as I, type ConfirmTone as J, CopyButton as K, type CopyButtonLabels as L, type CopyButtonProps as M, type CurrencyLabels as N, CurrentPasswordInput as O, type CurrentPasswordInputLabels as P, type CurrentPasswordInputProps as Q, DEFAULT_APP_SHELL_LABELS as R, DEFAULT_CALCULATOR_LABELS as S, DEFAULT_CHARACTER_COUNT_LABELS as T, DEFAULT_COMBOBOX_LABELS as U, DEFAULT_COMMON_LABELS as V, DEFAULT_CONFIRM_DIALOG_LABELS as W, DEFAULT_COPY_BUTTON_LABELS as X, DEFAULT_CURRENCY_LABELS as Y, DEFAULT_DANGER_CONFIRM_LABELS as Z, DEFAULT_DATE_PICKER_LABELS as _, type ButtonClassesOptions as a, type InputProps as a$, DEFAULT_FILE_PICKER_LABELS as a0, DEFAULT_FORM_ACTIONS_LABELS as a1, DEFAULT_IBAN_INPUT_LABELS as a2, DEFAULT_MULTI_SELECT_LABELS as a3, DEFAULT_PASSWORD_REVEAL_LABELS as a4, DEFAULT_PHONE_INPUT_LABELS as a5, DEFAULT_PICKER_SHEET_LABELS as a6, DEFAULT_SHARE_CARD_LABELS as a7, DEFAULT_SWIPEABLE_ROW_LABELS as a8, DEFAULT_TABS_LABELS as a9, type FilePickerLabels as aA, type FileRejection as aB, type FileRejectionReason as aC, type FileScreenOptions as aD, FloatingField as aE, type FloatingFieldProps as aF, FormActions as aG, type FormActionsAlign as aH, type FormActionsDestructive as aI, type FormActionsLabels as aJ, type FormActionsPlacement as aK, type FormActionsProps as aL, type FormActionsStickyWithin as aM, type FormActionsSubmitProps as aN, type FormActionsSubmitShortcut as aO, IbanInput as aP, type IbanInputLabels as aQ, type IbanInputProps as aR, IconButton as aS, type IconButtonGlyphSize as aT, type IconButtonLinkProps as aU, type IconButtonProps as aV, type IconButtonSize as aW, type IconButtonTone as aX, type IconButtonToneColor as aY, type IconButtonVariant as aZ, Input as a_, DEFAULT_TOP_BAR_LABELS as aa, DangerConfirm as ab, type DangerConfirmLabels as ac, type DangerConfirmProps as ad, type DangerConsequence as ae, type DatePickerLabels as af, EmptyState as ag, type EmptyStateProps as ah, FIELD_BASE as ai, FIELD_DISPLAY as aj, FIELD_FLOATING_PAD as ak, FIELD_INVALID as al, FIELD_TRIGGER as am, FIELD_WRITABLE_LOOK as an, FLOATING_INPUT_CLASS as ao, FLOATING_LABEL_CLASS as ap, FLOATING_LABEL_STATIC as aq, FieldChevron as ar, type FieldChevronProps as as, FieldHint as at, type FieldHintProps as au, FieldLabel as av, type FieldLabelProps as aw, FileButton as ax, type FileButtonProps as ay, type FileLabels as az, type ButtonLinkProps as b, useKitLocale as b$, type KitDateFormatContext as b0, type KitDateFormatter as b1, type KitLinkComponent as b2, type KitLinkProps as b3, Label as b4, type LabelOverride as b5, type LabelProps as b6, type MultiSelectLabels as b7, PHONE_QUERY as b8, type PasswordRevealLabels as b9, Textarea as bA, type TextareaProps as bB, type TopBarLabels as bC, TypedConfirmField as bD, type TypedConfirmFieldLabels as bE, type TypedConfirmFieldProps as bF, type TypedMatch as bG, type UiKitLabelOverrides as bH, type UiKitLabels as bI, UiKitProvider as bJ, type UiKitProviderProps as bK, type UseFilePickerOptions as bL, type UseFilePickerReturn as bM, buttonClasses as bN, formatFileSize as bO, matchesAccept as bP, missingKitLabels as bQ, resolvePasswordRevealLabels as bR, typedMatches as bS, useConfirm as bT, useFilePicker as bU, useKitChartTooltipPlacement as bV, useKitDateFormatter as bW, useKitFileLabels as bX, useKitLabelOverrides as bY, useKitLabels as bZ, useKitLink as b_, PhoneInput as ba, type PhoneInputLabels as bb, type PhoneInputProps as bc, type PickerSheetLabels as bd, type ResponsiveFormActionsPlacement as be, Select as bf, type SelectProps as bg, type ShareAddRequest as bh, type ShareCandidate as bi, ShareCard as bj, type ShareCardLabels as bk, type ShareCardProps as bl, ShareDialog as bm, type ShareDialogProps as bn, type ShareGrantee as bo, SharePanel as bp, type SharePanelProps as bq, type SharePendingGrant as br, type ShareRole as bs, Spinner as bt, type SpinnerProps as bu, type SwipeableRowLabels as bv, type TabItem as bw, Tabs as bx, type TabsLabels as by, type TabsProps as bz, type ButtonProps as c, useKitWeekStart as c0, type FilePickHandler as c1, usePromisePending as c2, formatAccept as c3, judgePick as c4, screenFiles as c5, summariseRejections as c6, 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, type ComboboxLabels as z };