@eifi1/ui-kit 0.22.0 → 0.24.0

package/dist/{kit-labels-R8mIAc9N.d.ts → feedback-DOwPu-Il.d.ts}

@@ -1,12 +1,12 @@
 import * as react from 'react';
-import { InputHTMLAttributes, ReactNode, AnchorHTMLAttributes, Ref, ReactElement, ButtonHTMLAttributes, SelectHTMLAttributes, ComponentPropsWithoutRef, TextareaHTMLAttributes } from 'react';
+import { InputHTMLAttributes, ReactNode, AnchorHTMLAttributes, Ref, ReactElement, ButtonHTMLAttributes, SelectHTMLAttributes, ComponentPropsWithoutRef, TextareaHTMLAttributes, RefObject } 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';
@@ -23,15 +23,13 @@ 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, t as FeedbackDialogTextLabels } from './feedback-attachment-NhUm7Zga.js';
-import { FeedbackThreadLabels, FeedbackComposerLabels } from './feedback/feedback-thread.js';
+import { LucideIcon } from 'lucide-react';
 import { AccountSettingsLabels } from './components/account-settings-labels.js';
 import { FloatingPanelLabels } from './components/floating-panel.js';
 import { BulkActionBarLabels } from './components/bulk-action-bar.js';
 import { ListLabels } from './components/list.js';
 import { BreadcrumbsLabels } from './components/breadcrumbs.js';
 import { ToastLabels } from './components/toast.js';
-import { LucideIcon } from 'lucide-react';
 import { DescriptionListLabels } from './components/description-list.js';
 import { LineItemsLabels } from './components/line-items.js';
 import { ProgressBarLabels } from './components/progress-bar.js';
@@ -51,6 +49,8 @@ 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";
@@ -568,7 +568,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`
@@ -625,15 +624,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
@@ -1416,6 +1406,18 @@ interface DangerConfirmLabels {
     /** 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. */
@@ -1427,7 +1429,31 @@ declare const DEFAULT_DANGER_CONFIRM_LABELS: {
     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.
@@ -1449,12 +1475,25 @@ interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onCh
      * (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) => void | Promise<unknown>;
-    /** Show a password field; confirm stays disabled until it is filled. */
+    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 stays disabled until it is ticked
+     * 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").
      *
@@ -1475,8 +1514,8 @@ interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onCh
      * 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"`). */
+    /** 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
@@ -1490,15 +1529,99 @@ interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onCh
     /** 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. */
+     *  cost (loading demo data over your own). Colours the prompt, and picks the arm
+     *  button's variant and — unless {@link DangerConfirmProps.confirmVariant} is
+     *  given — the confirm's. */
     tone?: "danger" | "warning";
+    /**
+     * The confirm button's variant, apart from `tone` (0.24, keksdose). Default: what
+     * `tone` picks, as before — `"danger"` for `"danger"`, `"primary"` for `"warning"`.
+     *
+     * `tone` says how bad the outcome is; this says how loud the last press is, and the two
+     * need not agree. keksdose's `UserActionConfirm` (an admin resets somebody else's
+     * password) asks an AMBER question — what it guards against is mis-targeting, not data
+     * loss, so the danger colour stays its one `severe` consequence's — and ends in a RED
+     * Go, as its hand-built panel did before it moved onto this tile in 0.23; with only
+     * `tone`, the amber question made Go the neutral primary fill. `tone="warning"
+     * confirmVariant="danger"` is that panel again.
+     */
+    confirmVariant?: ButtonVariant;
+    /**
+     * Hold the armed confirm for a reason of the CALLER's own (0.24, keksdose) — the
+     * tile's counterpart of FormActions' `submitDisabledReason`. While it has content the
+     * confirm is held exactly as by the built-in guards: `aria-disabled` but focusable,
+     * the reason in the kit {@link Tooltip} and its description, a press — or Enter in a
+     * field — does nothing. Nothing else changes: the arm button stays usable, and no
+     * line is printed under the buttons.
+     *
+     * keksdose's `UserPlanEditor` ("move this account onto another plan") must not confirm
+     * the plan the account already holds — the request would only write FREE → FREE into
+     * the audit trail. With no guard of its own to give, it passed "Pick a different plan"
+     * as `lockedReason`, which is a LOCK: documented as "the action is not available",
+     * spelled out under the buttons as well as in the tooltip, and meant for a write the
+     * user cannot make land. A guard the user lifts by changing a field is this prop.
+     *
+     * Which reason the held confirm names: a write lock's first (`lockedReason`, `commit`
+     * — nothing in the tile lifts it), then this one, then the built-in guards in the
+     * order they are drawn (the tick, the phrase, the password). This one before the
+     * built-ins because it is usually about a field in
+     * {@link DangerConfirmProps.children}, which is drawn ABOVE them — the rule since 0.23
+     * is "the first open guard in the order the user meets it" — and because it is about
+     * WHAT is being confirmed (which plan), which has to be settled before acknowledging
+     * it means anything. It is also the order keksdose's plan editor had, its
+     * `lockedReason` winning over the tick.
+     */
+    confirmDisabledReason?: ReactNode;
+    /**
+     * Fields of the caller's own, drawn INSIDE the armed tile (0.24, keksdose): after the
+     * prompt and the consequences, before the tick, the typed phrase and the password —
+     * the order is "what this does, what to do it with, then prove you mean it". Nothing
+     * is drawn for them while the tile is disarmed, and nothing at all without them, so a
+     * tile without children is laid out exactly as before.
+     *
+     * keksdose's `UserPlanEditor` asks WHICH plan before it asks for the tick; with no
+     * place inside the tile for the picker, the `Select` sat above it, and the tile's
+     * prompt — the panel's title by rights — became the "FREE → PRO" line under the
+     * picker. With the picker here, the prompt is the title again.
+     *
+     * The fields are the caller's: their values are not wiped on disarm (an uncontrolled
+     * field starts over anyway — the slot unmounts), not passed to `onConfirm`, and a
+     * guard on them is {@link DangerConfirmProps.confirmDisabledReason}. Arming moves
+     * focus to their first form field (an input, a select, a combobox, a radio…), else to
+     * the tile's own first field as before; Tab then goes on through the tick, the phrase
+     * and the password to Cancel and the confirm. They sit inside the tile's `<form>`:
+     * Enter in a text field confirms once every guard allows, and a {@link Button} among
+     * them needs `type="button"` — without one it SUBMITS the form, as a native button
+     * does.
+     */
+    children?: ReactNode;
     /** 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. */
+    /**
+     * The action is running: confirm shows a spinner and nothing can be pressed — Cancel
+     * included. For a caller that tracks the mutation itself (a `useMutation`'s
+     * `isPending`); a promise returned from `onConfirm` does the same on its own.
+     *
+     * Cancel stays disabled ON PURPOSE, unlike FormActions' (keksdose asked in 0.24 why the
+     * two differ). Once the request has left, nothing on the client can call it back —
+     * not even an `AbortSignal`, which only stops the waiting, not the server — so a usable
+     * Cancel could only collapse the tile while the action went on: "Cancel" pressed, and
+     * the account reset anyway. Every way of settling what comes back is wrong somewhere: a
+     * resolve after the Cancel did what the user called off; a reject finds the fields
+     * wiped (a collapsed tile holds no password), so the 0.23 "stay armed and retry" is
+     * gone; and re-arming while the first request runs is either a busy tile with empty
+     * fields or — if the busy state went with the Cancel — a second destructive request
+     * beside the first. FormActions' Cancel leaves an editor whose save is the user's own
+     * edit landing, and a form can be edited again; the tile's action is the one that
+     * cannot be undone, so it says nothing it cannot keep and waits — the wait is one
+     * request long.
+     *
+     * When the action settles still armed (it failed) and the press on the confirm had
+     * dropped the focus — a natively disabled button loses it — focus comes back to the
+     * confirm, so a keyboard user can retry or Shift+Tab to the field to correct (0.24).
+     */
     busy?: boolean;
     /** The arm button is disabled. */
     disabled?: boolean;
@@ -1533,9 +1656,21 @@ interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onCh
 }
 /**
  * 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.
+ * warning, an optional list of consequences, optional fields of the caller's own
+ * (`children`, 0.24), 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 — the built-in ones, and the caller's `confirmDisabledReason` (0.24).
+ *
+ * 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, the caller's guard over the
+ * built-in ones; while the action runs the confirm is plainly disabled, its spinner
+ * saying why — and so is Cancel, which cannot call back a request that has left (see
+ * `busy`).
  *
  * 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
@@ -1547,7 +1682,7 @@ interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onCh
  * 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;
+declare function DangerConfirm({ onConfirm, requirePassword, requireAcknowledge, consequences, phrase, phraseMatch, prompt, tone, confirmVariant, confirmDisabledReason, children, 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
@@ -1777,6 +1912,1090 @@ interface FileButtonProps extends Omit<UseFilePickerOptions, "disabled">, Omit<B
  */
 declare const FileButton: react.ForwardRefExoticComponent<FileButtonProps & react.RefAttributes<HTMLButtonElement>>;
 
+interface FeedbackCategoryOption {
+    value: string;
+    label: string;
+}
+interface FeedbackAttachmentLabels {
+    /** The heading over the field. Optional: a note editor puts the buttons
+     *  straight under its textarea, where a second heading is noise. */
+    attachment?: string;
+    attachmentAdd: string;
+    /** Label for the "capture screenshot" button. Optional — falls back to the provider's
+     *  `feedbackAttachment.attachmentCapture`, then English. */
+    attachmentCapture?: string;
+    /** The line under the attachment buttons saying a screenshot can be pasted
+     *  straight in. Optional — falls back to the provider's `feedbackAttachment`, then English. */
+    attachmentPaste?: string;
+    attachmentRemove: string;
+    /** `multiple` mode (0.15.5): the chip list's accessible name — and, in
+     *  `<FeedbackDialog attachments="multiple">`, the heading over it (0.16.0). Optional,
+     *  as are the keys below — they fall back to the provider's `feedbackAttachment`,
+     *  then English. */
+    attachmentList?: string;
+    /** `multiple` mode (0.16.0): the screenshot slot's chip title, in place of its file name. */
+    attachmentScreenshot?: string;
+    /** `multiple` mode: one chip's remove button, given the file's name. */
+    attachmentRemoveFile?: (name: string) => string;
+    /** `multiple` mode: the line shown once `max` files are attached. */
+    attachmentLimit?: (max: number) => string;
+    /** `refs` mode (0.22.0): the second line of a chip whose upload is still running. */
+    attachmentUploading?: string;
+}
+interface FeedbackDialogLabels extends FeedbackAttachmentLabels {
+    title: string;
+    category: string;
+    subject: string;
+    body: string;
+    attachment: string;
+    submitHint: string;
+    cancel: string;
+    save: string;
+    /** @deprecated since 0.16.0 — use `attachmentList`, the one key for the heading and
+     *  the chip list it names. Still honoured: set, it wins over the provider's
+     *  `attachmentList` (but not over an `attachmentList` passed beside it). */
+    attachments?: string;
+}
+/**
+ * The dialog's own strings — the `feedbackDialog` namespace of `<UiKitProvider
+ * labels>` (0.12.0). The attachment keys are not repeated here: they are the
+ * `feedbackAttachment` namespace's, which the field inside already reads.
+ *
+ * Before, every key was required at the call site, so each app restated ten strings
+ * wherever it mounted the dialog (kastlan feedback-button.tsx built the object inline).
+ */
+interface FeedbackDialogTextLabels {
+    title: string;
+    category: string;
+    subject: string;
+    body: string;
+    /** The body's label when `requireBody={false}`: "What happened? (optional)".
+     *  Optional, so a complete `UiKitLabels` typed before 0.14.2 still compiles. */
+    bodyOptional?: string;
+    /** The heading over the attachment buttons. */
+    attachment: string;
+    /** The line beside the buttons naming the shortcut. */
+    submitHint: string;
+    cancel: string;
+    save: string;
+    /** @deprecated since 0.16.0 — use `feedbackAttachment.attachmentList`. It and this
+     *  key were two names for one heading ("Attachments" over the chips that list names
+     *  "Attachments"), and a catalogue that translated one left the other English. Still
+     *  honoured when set: it wins over `feedbackAttachment.attachmentList`. */
+    attachments?: string;
+}
+declare const DEFAULT_FEEDBACK_DIALOG_LABELS: FeedbackDialogTextLabels;
+interface FeedbackSubmission {
+    title: string;
+    body: string;
+    category: string;
+    attachment: File | null;
+}
+/**
+ * What `onSubmit` gets under `attachments="multiple"` (0.15.5): the screenshot and
+ * the picked/pasted files apart, because an app files them differently — keksdose
+ * attaches the screenshot to the report and the photos as its evidence list. No
+ * `attachment`: there is no one file it could name.
+ */
+interface FeedbackMultipleSubmission {
+    title: string;
+    body: string;
+    category: string;
+    /** What `onCaptureScreenshot` returned, or `null` — at most one. */
+    screenshot: File | null;
+    /** Picked and pasted files, in the order they were added; at most `maxAttachments`. */
+    attachments: File[];
+}
+interface FeedbackDialogBaseProps {
+    open: boolean;
+    onClose: () => void;
+    categories: FeedbackCategoryOption[];
+    category: string;
+    onCategoryChange: (value: string) => void;
+    /** Prop > `<UiKitProvider labels={{ feedbackDialog, feedbackAttachment }}>` >
+     *  English. Optional since 0.12.0; a whole `FeedbackDialogLabels` still fits. */
+    labels?: Partial<FeedbackDialogLabels>;
+    submitting?: boolean;
+    contextSlot?: ReactNode;
+    attachmentAccept?: string[];
+    maxAttachmentBytes?: number;
+    /**
+     * Optional: capture a screenshot of the underlying app view and return it as a
+     * File. When provided, a "Capture screenshot" button is shown next to "Add
+     * attachment"; the returned file is fed through the same validation + preview.
+     */
+    onCaptureScreenshot?: () => Promise<File | null>;
+    /**
+     * `false`: a report with only a subject can be sent, and the body's label says it is
+     * optional (`bodyOptional`, unless `labels.body` is passed). Default `true`, the
+     * dialog's behaviour until 0.14.2 (keksdose K1: its backend takes title-only reports).
+     */
+    requireBody?: boolean;
+}
+/** One attachment — a screenshot, a picked or a pasted image; a second replaces
+ *  nothing, it has to wait for the first to be removed. The default. */
+interface FeedbackDialogSingleProps extends FeedbackDialogBaseProps {
+    attachments?: "single";
+    onSubmit: (data: FeedbackSubmission) => void | Promise<void>;
+    /** `info` (0.23.0) names the refused file and the limit — see
+     *  {@link FeedbackAttachmentErrorInfo}. */
+    onAttachmentError?: (kind: "type" | "size", info: FeedbackAttachmentErrorInfo) => void;
+    /** Multiple mode only — refused here rather than silently ignored. */
+    maxAttachments?: never;
+}
+/**
+ * One screenshot plus up to `maxAttachments` picked or pasted files (0.15.5, keksdose
+ * dev#578: "pasted two photos, the second overwrote the first"). The capture button is
+ * offered while there is no screenshot yet; the add button while there is room.
+ */
+interface FeedbackDialogMultipleProps extends FeedbackDialogBaseProps {
+    attachments: "multiple";
+    /** Default `DEFAULT_MAX_ATTACHMENTS` (5). The screenshot does not count. */
+    maxAttachments?: number;
+    onSubmit: (data: FeedbackMultipleSubmission) => void | Promise<void>;
+    /** `"count"`: more files arrived at once than there was room for; the surplus was
+     *  dropped. `info` (0.23.0) names the refused file(s) and the limit. */
+    onAttachmentError?: (kind: FeedbackAttachmentError, info: FeedbackAttachmentErrorInfo) => void;
+}
+type FeedbackDialogProps = FeedbackDialogSingleProps | FeedbackDialogMultipleProps;
+/**
+ * The generic feedback form dialog: category + subject + body + an optional image
+ * attachment, with Ctrl/Cmd+Enter to submit. Domain-free — the app supplies the
+ * category options, labels and an `onSubmit` that talks to its own backend, plus
+ * an optional `contextSlot` for app-specific context (user, current URL, …).
+ *
+ * **A screenshot can be pasted straight in.** Ctrl/Cmd+V anywhere in the dialog
+ * takes an image off the clipboard and makes it the attachment, through the same
+ * validation and the same preview as the file picker. It is the gesture the two
+ * ways in did not cover: `onCaptureScreenshot` snapshots the *whole* app view,
+ * and the file picker needs a file — so somebody who wanted to show one panel,
+ * or one region of one, had to save a crop to disk first and then find it again
+ * (Steering Design feedback #39). The clipboard is where a region snip already
+ * is on every platform.
+ *
+ * **`attachments="multiple"`** (0.15.5) takes several: every paste and pick adds a
+ * chip, and `onSubmit` gets `{ screenshot, attachments }` ({@link
+ * FeedbackMultipleSubmission}) instead of `attachment`. Opt-in, so a caller typed
+ * against the one-file submission keeps compiling and behaving as before.
+ */
+declare function FeedbackDialog(props: FeedbackDialogProps): react.JSX.Element | null;
+
+declare const DEFAULT_ATTACHMENT_ACCEPT: string[];
+declare const DEFAULT_MAX_ATTACHMENT_BYTES: number;
+/** How many files `<FeedbackAttachmentField multiple>` takes when `max` is not given
+ *  (0.15.5). Five photos of one problem is already a lot to look through; a report
+ *  that needs more is a conversation, which the thread is for. */
+declare const DEFAULT_MAX_ATTACHMENTS = 5;
+/**
+ * The field's own strings — the `feedbackAttachment` namespace of `<UiKitProvider
+ * labels>`. The keys are {@link FeedbackAttachmentLabels}' own, so the `labels` prop
+ * (and a whole `FeedbackDialogLabels` handed down by the dialog) merges over them
+ * one to one. The optional heading, `attachment`, stays a prop: a note editor puts
+ * the buttons straight under its textarea and wants none.
+ *
+ * Before 0.7.0 the two optional keys fell back to hard-coded English, so a German app
+ * that relied on its provider got "Capture screenshot" under a German form.
+ *
+ * The three keys added in 0.15.5 for `multiple` mode are optional, so a complete
+ * `UiKitLabels` typed before it still compiles; they fall back to English. So is
+ * `attachmentScreenshot` (0.16.0).
+ */
+interface FeedbackAttachmentFieldLabels {
+    attachmentAdd: string;
+    attachmentCapture: string;
+    attachmentPaste: string;
+    attachmentRemove: string;
+    /** `multiple` mode: the accessible name of the list of chosen files — and, since
+     *  0.16.0, the heading `<FeedbackDialog attachments="multiple">` puts over it. */
+    attachmentList?: string;
+    /** `multiple` mode (0.16.0): what the screenshot slot's chip is called — "Screenshot"
+     *  rather than the capture's file name ("screenshot.webp"), which says nothing a
+     *  reporter chose. The file name stays as the chip's second line. */
+    attachmentScreenshot?: string;
+    /** `multiple` mode: one chip's remove button — "Remove photo.jpg". Named per file,
+     *  because five buttons all called "Remove attachment" say nothing about which. */
+    attachmentRemoveFile?: (name: string) => string;
+    /** `multiple` mode: the line shown in place of the add buttons once `max` is reached. */
+    attachmentLimit?: (max: number) => string;
+    /** `refs` mode (0.22.0, keksdose K16): the second line of a chip whose upload is still
+     *  running, where an uploaded one shows its size — "Uploading…". Optional, like the
+     *  keys above, so a `UiKitLabels` typed before it still compiles. */
+    attachmentUploading?: string;
+    /** `refs` mode (0.23.0, keksdose G5a): {@link FeedbackAttachmentErrorInfo.message} for
+     *  an `"upload"` refusal — "“huge.png” could not be uploaded". The other refusals'
+     *  sentences are the `filePicker` namespace's, shared with FileButton. Optional, like
+     *  the keys above. */
+    attachmentUploadFailed?: (name: string) => string;
+}
+declare const DEFAULT_FEEDBACK_ATTACHMENT_LABELS: FeedbackAttachmentFieldLabels;
+/** Why a file was turned away. `"count"` only ever comes from `multiple` (and `refs`)
+ *  mode: more files arrived at once than `max` left room for, and the surplus was
+ *  dropped. */
+type FeedbackAttachmentError = "type" | "size" | "count";
+/** `refs` mode's reasons: {@link FeedbackAttachmentError}, or `"upload"` — `onUpload`
+ *  rejected, and what it rejected with is `onError`'s second argument. A type of its
+ *  own so a host's exhaustive switch over the File modes' reasons stays exhaustive. */
+type FeedbackAttachmentRefsError = FeedbackAttachmentError | "upload";
+/**
+ * What `onError` knows about a refusal beyond its kind (0.23.0, keksdose G5a): the file
+ * it was about, the limit that refused it, and a sentence that says both.
+ *
+ * keksdose's support chat toasted "File too large" with no name — the field's `onError`
+ * carried a kind and nothing else, so a refusal could not say WHICH of three pasted
+ * screenshots went, nor what the ceiling was, and its own `AttachmentPicker` (a
+ * FileButton, whose `onReject` hands over `{ file, message }`) said more than the kit's
+ * field would have. This is that, for every mode.
+ *
+ * It arrives as an EXTRA argument, after the ones `onError` already had, so a handler
+ * written for 0.22 — `(kind) => …`, or `refs` mode's `(kind, error) => …` — compiles
+ * and behaves as before:
+ *
+ * - single and `multiple`: `onError(kind, info)`;
+ * - `refs`: `onError(kind, error, info)` — the second place is `onUpload`'s rejection
+ *   since 0.22 (`undefined` for the other kinds, as it always was), so the info comes
+ *   third rather than changing what a 0.22 handler reads there. It also carries that
+ *   `error`, so one helper `(kind, info) => …` serves all three modes.
+ *
+ * An object rather than more positional arguments because what a host reaches for
+ * differs by kind — the bytes for `"size"`, `max` for `"count"`, the server's answer for
+ * `"upload"` — and a field added later must not shift anyone's arguments.
+ */
+interface FeedbackAttachmentErrorInfo {
+    /** The file refused — under the name the field would have given it (a pasted image
+     *  is already "pasted.png"). For `"count"`, the first of the surplus; for
+     *  `"upload"`, the file whose upload failed. */
+    file: File;
+    /** `"count"`: every file of the surplus (several can arrive in one pick). Otherwise
+     *  `[file]`. */
+    files: File[];
+    /**
+     * One translated sentence naming the file and the limit — the ones FileButton's
+     * `onReject` hands over, from the same `filePicker` namespace: "“huge.png” is larger
+     * than 10 MB", "Only image/png, image/jpeg files", "“c.png” was not added: at most 5
+     * files" (several at once: "3 files were not added"). `"upload"`: the field's own
+     * `attachmentUploadFailed`, "“huge.png” could not be uploaded" — a host with a better
+     * sentence from the server's answer uses `error`. Ready for a toast as it is.
+     */
+    message: string;
+    /** The field's `maxBytes` — the ceiling a `"size"` refusal went over, in bytes. */
+    maxBytes: number;
+    /** The field's `accept` — the types a `"type"` refusal was not among. */
+    accept: string[];
+    /** The field's `max` — the ceiling a `"count"` refusal hit. Absent in single mode,
+     *  which holds one file by definition. */
+    max?: number;
+    /** `"upload"` only: what `onUpload` rejected with — `onError`'s second argument. */
+    error?: unknown;
+}
+/**
+ * One uploaded attachment in `refs` mode: what the host's upload answered with. `key`
+ * identifies it (a storage key, an upload id) and is what a remove goes by; `name` is
+ * what the chip says. `size` (bytes) and `type` (mime) are optional — given, the chip
+ * shows the size and an image icon or a file icon accordingly.
+ */
+interface FeedbackAttachmentRef {
+    key: string;
+    name: string;
+    size?: number;
+    type?: string;
+}
+interface FeedbackAttachmentFieldBaseProps {
+    /** Prop > `<UiKitProvider labels={{ feedbackAttachment }}>` > English. Optional
+     *  since 0.7.0; `attachment` (the heading) is only ever read from here. */
+    labels?: Partial<FeedbackAttachmentLabels> & Pick<Partial<FeedbackAttachmentFieldLabels>, "attachmentUploading" | "attachmentUploadFailed">;
+    accept?: string[];
+    maxBytes?: number;
+    /**
+     * Take no files for now (0.23.0, keksdose G5b): the add and capture buttons, the
+     * hidden file input and every chip's remove button are natively disabled, and a paste
+     * is let through untouched. The chips stay as they are — what is about to be sent
+     * stays readable.
+     *
+     * For the moment a send is in flight. keksdose's support picker is `disabled` while
+     * the message goes out, because the message carries the attachments AS THEY WERE at
+     * the press: a chip removed mid-send has gone with it all the same, and one added
+     * mid-send looks as if it had. The field has no drop target; the paste is its drop.
+     *
+     * This is a pause, not a lock that explains itself — for that, `refs` mode (the mode
+     * that commits) takes `commit` and `disabledReason`.
+     */
+    disabled?: boolean;
+    /** Snapshot the app view behind this and return it as a File. A "Capture
+     *  screenshot" button appears only when it is given. */
+    onCaptureScreenshot?: () => Promise<File | null>;
+    /** Listen for the paste on `document` rather than on this field's own
+     *  subtree. For a modal, which owns the whole page while it is up. */
+    documentPaste?: boolean;
+    /** Listen for the paste within this element's subtree rather than this
+     *  field's own — for a field standing *beside* the text box a paste is made
+     *  in, whose common parent is where the event bubbles to. Ignored when
+     *  `documentPaste` is set. */
+    pasteFrom?: RefObject<HTMLElement | null>;
+    /**
+     * The add and capture buttons' look (0.24.0, keksdose) — Button's own `variant`.
+     * Default `"secondary"`, the look they always had.
+     *
+     * keksdose's support chat puts this field in ChatComposer's `attachmentSlot`, in the
+     * row with Send, where its own picker had been a `ghost` / `sm` FileButton: two
+     * bordered full-size buttons under a chat box read as a second form, and the field
+     * gave no way to say otherwise. Every mode, wherever the buttons appear; the chips'
+     * remove buttons keep their size.
+     */
+    buttonVariant?: ButtonVariant;
+    /** The add and capture buttons' size — Button's own `size`, with `buttonVariant`.
+     *  Default `"md"`. `"sm"` draws their icons at 14px, as a small button's are. */
+    buttonSize?: ButtonSize;
+    className?: string;
+}
+/** One file: choosing a second means removing the first. The field's only mode until 0.15.5. */
+interface FeedbackAttachmentFieldSingleProps extends FeedbackAttachmentFieldBaseProps {
+    multiple?: false;
+    refs?: false;
+    value: File | null;
+    onChange: (file: File | null) => void;
+    /** A file was refused. `info` (0.23.0) names it and the limit — see
+     *  {@link FeedbackAttachmentErrorInfo}. */
+    onError?: (kind: "type" | "size", info: FeedbackAttachmentErrorInfo) => void;
+    max?: never;
+    screenshot?: never;
+    onScreenshotChange?: never;
+    commit?: never;
+    disabledReason?: never;
+}
+/**
+ * Several files (0.15.5, keksdose dev#578: "pasted two photos, the second overwrote
+ * the first"). Every way in ADDS — a pick of several files, a paste, a capture — up to
+ * `max`, and each file is a removable chip.
+ */
+interface FeedbackAttachmentFieldMultipleProps extends FeedbackAttachmentFieldBaseProps {
+    multiple: true;
+    refs?: false;
+    value: File[];
+    onChange: (files: File[]) => void;
+    /** How many files `value` may hold. Default {@link DEFAULT_MAX_ATTACHMENTS} (5). The
+     *  add buttons and the paste hint are offered only while there is room. */
+    max?: number;
+    /** Per file: a rejected one is reported and the others are still added. `"count"` is
+     *  once per pick, with the whole surplus in `info.files`. `info` (0.23.0): see
+     *  {@link FeedbackAttachmentErrorInfo}. */
+    onError?: (kind: FeedbackAttachmentError, info: FeedbackAttachmentErrorInfo) => void;
+    /**
+     * A separate slot for THE screenshot, outside `value` and `max`. Given
+     * `onScreenshotChange`, what `onCaptureScreenshot` returns lands here instead of in
+     * `value`, shown as the first chip, and the capture button is offered only while the
+     * slot is empty — a second snapshot of the same view is not more evidence. This is
+     * how `<FeedbackDialog attachments="multiple">` keeps the screenshot apart from the
+     * photos; a form built from the parts can do the same.
+     */
+    screenshot?: File | null;
+    onScreenshotChange?: (file: File | null) => void;
+    commit?: never;
+    disabledReason?: never;
+}
+/**
+ * Uploaded on pick (0.22.0, keksdose K16). keksdose's support chat uploads each file
+ * the moment it is chosen and sends the message with the REFS the uploads answered —
+ * a 10 MB screenshot is refused while the reporter is still typing, not when they
+ * press Send — so its `AttachmentPicker` could not use this field, whose value is
+ * `File`s held until the form is submitted. Here the value is
+ * {@link FeedbackAttachmentRef}s: every way in (pick, paste, capture) validates the
+ * file as the other modes do, then hands it to `onUpload` and shows a chip with a
+ * spinner until it answers; the ref it resolves to joins `value` through `onChange`.
+ * A rejection drops the chip and reports `onError("upload", error)`. A chip is removed
+ * BY KEY: `onChange` gets the list without it, and `onRemove` the key, for a host that
+ * deletes the upload on the server too.
+ *
+ * Uploads still running count against `max`, so five picks in quick succession cannot
+ * overshoot it; they are not in `value` until they land, so a send that reads `value`
+ * sends only what has arrived — hold Send back while {@link onUploadingChange} says
+ * an upload is running. Several files upload side by side and join in the order they
+ * finish. The File modes are unchanged.
+ */
+interface FeedbackAttachmentFieldRefsProps extends FeedbackAttachmentFieldBaseProps {
+    refs: true;
+    multiple?: never;
+    value: FeedbackAttachmentRef[];
+    onChange: (refs: FeedbackAttachmentRef[]) => void;
+    /** Upload one file; resolve to its ref, or reject to refuse it. Called once per
+     *  accepted file, the moment it is chosen. */
+    onUpload: (file: File) => Promise<FeedbackAttachmentRef>;
+    /** A chip was removed — after `onChange` — with its ref's key. */
+    onRemove?: (key: string) => void;
+    /** Whether any upload is running: `true` when the first starts, `false` when the
+     *  last settles — for the host's Send, which should wait. */
+    onUploadingChange?: (uploading: boolean) => void;
+    /** How many refs `value` may hold, uploads in flight included. Default
+     *  {@link DEFAULT_MAX_ATTACHMENTS} (5). */
+    max?: number;
+    /** Per file. `"upload"` carries what `onUpload` rejected with as `error` (`undefined`
+     *  for the other kinds). `info` (0.23.0) comes third so a 0.22 handler's `error` is
+     *  still the second argument — see {@link FeedbackAttachmentErrorInfo}. */
+    onError?: (kind: FeedbackAttachmentRefsError, error: unknown, info: FeedbackAttachmentErrorInfo) => void;
+    /**
+     * This field COMMITS (0.23.0): each file is uploaded the moment it is chosen, and a
+     * remove may delete the upload (`onRemove`) — a save, unlike the File modes, which
+     * only stage a file for a form sent later (and so stay open under a lock, like every
+     * field). 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.
+     */
+    commit?: boolean;
+    /**
+     * Why no file can be added or removed — the write lock's sentence, a quota, a thread
+     * closed to replies. Unlike `disabled`, it SAYS so, the kit's commit-control way: the
+     * buttons (add, capture, every chip's remove) stay focusable, `aria-disabled`, with
+     * the reason in the kit Tooltip and their description; no pick, paste or remove gets
+     * through; and the reason stands where the paste hint was, for a phone that never
+     * hovers. The chips stay readable.
+     */
+    disabledReason?: ReactNode;
+    screenshot?: never;
+    onScreenshotChange?: never;
+}
+type FeedbackAttachmentFieldProps = FeedbackAttachmentFieldSingleProps | FeedbackAttachmentFieldMultipleProps | FeedbackAttachmentFieldRefsProps;
+/**
+ * Picking one picture: the file dialog, a capture of the app view, or a paste.
+ * With `multiple`, picking several (see {@link FeedbackAttachmentFieldMultipleProps}).
+ *
+ * Lifted out of {@link FeedbackDialog} so the *reply* half of the feature can
+ * have it too (Steering Design feedback #128). A report is a conversation — it
+ * is filed, it is answered, and the reporter sends it back saying that is not
+ * what they meant — and the screenshot showing what they mean is taken at
+ * whichever of those points they looked. Only the first of them had a way to
+ * attach one, so everything after it had to be described in words.
+ *
+ * **Three ways in, and they are three because no one of them covers the others.**
+ * The file dialog needs a file on disk; `onCaptureScreenshot` snapshots the
+ * *whole* app view; and the clipboard is where a region snip already is on every
+ * platform (Steering Design feedback #39). Somebody who wanted to show one panel
+ * had to save a crop and then find it again.
+ *
+ * `documentPaste` and `pasteFrom` decide where the paste is listened for, and
+ * it is a real choice rather than a flag with a default. A modal traps focus,
+ * so while it is up every paste in the page is meant for it — including one
+ * made with nothing in particular focused, which never reaches a React
+ * `onPaste` on a child: that is `documentPaste`. An editor **inline on a
+ * page** is not that: the page around it has its own fields, so it listens
+ * within its own subtree and a paste elsewhere stays where it was aimed. But
+ * "its own subtree" has to include the text box the paste is actually made in,
+ * and that box is this field's *sibling*, not its child — a paste in it bubbles
+ * to their common parent and never through here. `pasteFrom` is that parent
+ * (Steering Design feedback #140): the element whose subtree is listened to,
+ * handed in by whoever renders both the box and this field side by side.
+ */
+declare function FeedbackAttachmentField(props: FeedbackAttachmentFieldProps): react.JSX.Element;
+/** What a pasted image is called once it is an attachment.
+ *
+ *  The extension is read off the mime type rather than assumed to be `.png`:
+ *  Safari puts TIFF on the clipboard and a file called `pasted.png` that is not
+ *  a PNG is one the receiving end opens wrong. */
+declare function pastedName(type: string): string;
+
+/**
+ * The feedback **inbox**, as the parts two apps were each writing separately.
+ *
+ * `feedback-dialog.tsx` next door is the other half — the form somebody files a
+ * report with — and the split between them is the same one: this owns the
+ * *vocabulary*, the *policy* about how a report moves, and the *look*; the app
+ * owns the data, the API and every string.
+ *
+ * It exists because both apps had grown their own copy. Keksdose's is the one
+ * this is lifted from, comments and all, because it is the one that had been
+ * argued with users for a year — the glyph per status, the two sizes of the
+ * status control, what a row offers from where it currently stands. Steering
+ * Design's was thinner in every one of those places and read as a different
+ * product for no reason anyone chose.
+ *
+ * **What is deliberately NOT here.** The two apps store a report differently and
+ * are meant to: one keeps the reporter's context in a JSON column and the
+ * screenshot in an object store, the other keeps a `page_path` and the bytes in
+ * the row. So there is no `Feedback` type in this file and nothing here takes
+ * one. Every component takes the values it draws, and the detail panel is a
+ * *shell* the app fills — which is what lets each keep the shape that suits it
+ * without either of them inventing a second look for a status pill.
+ */
+/** The seven states a report can be in.
+ *
+ *  Shared value for value across both apps on purpose: it is what lets one habit,
+ *  and one agent prompt, work on either repo. Four are a chain and three sit off
+ *  it — see {@link visibleFeedbackStatuses} for what that buys. */
+type FeedbackStatus = "OPEN" | "IN_PROGRESS" | "IN_EVALUATION" | "NEEDS_LIVE_TEST" | "POSTPONED" | "DONE" | "WONT_DO";
+/** What a report is about. `CRASH` is filed by an error boundary and never
+ *  chosen, which is exactly why it is loud below and absent from every picker. */
+type FeedbackCategory = "CRASH" | "BUG" | "IDEA" | "QUESTION" | "OTHER";
+/**
+ * A glyph and a tone per status.
+ *
+ * Colour alone is not a label — two of these sit a hue apart, and a consumer who
+ * moves `--brand` can park it beside any of the others — so every status carries
+ * its own shape as well. Declaration order is chain order, and
+ * {@link FEEDBACK_STATUS_ORDER} is derived from it rather than restated, because
+ * a restated list cannot be checked for exhaustiveness: an eighth status would
+ * break the build here and leave a literal seven long.
+ */
+declare const FEEDBACK_STATUS_META: Record<FeedbackStatus, {
+    icon: LucideIcon;
+    activeBg: string;
+    activeText: string;
+}>;
+/** Chain order, then the three off it. The order a picker offers, and the rank a
+ *  status column sorts by — so a list sorted by status reads as a queue rather
+ *  than as an alphabet. */
+declare const FEEDBACK_STATUS_ORDER: FeedbackStatus[];
+/** The next status along the chain, or null at the end (or off it, as `WONT_DO`
+ *  is). What a swipe-to-advance gesture commits. */
+declare function nextFeedbackStatus(current: FeedbackStatus): FeedbackStatus | null;
+/**
+ * The steps that make sense from where a row currently stands.
+ *
+ * For the compact control in a table cell: it is a glanceable triage affordance,
+ * and a row of seven icons in a cell is noise. One step forward, one step back
+ * (so an item can be sent back for rework), and any of the three off-chain
+ * verdicts — which is what makes those usable as verdicts at all.
+ *
+ * The two parking states are not dead ends: each offers the step that resumes
+ * work and the ones that close it, but deliberately **not each other** —
+ * "postponed" and "waiting on a deploy" are different answers to different
+ * questions, and a row moving between them directly is a re-triage, which starts
+ * by picking the work back up.
+ */
+declare function visibleFeedbackStatuses(current: FeedbackStatus): FeedbackStatus[];
+/**
+ * Every status, in chain order — what an EXPANDED row offers.
+ *
+ * {@link visibleFeedbackStatuses} narrows the choice to the steps that make
+ * sense from where a row is, which is right for a table cell. Once the row is
+ * open in front of you, that same narrowing turns every non-adjacent move into a
+ * walk: OPEN to DONE meant three round trips, and WONT_DO could not be left at
+ * all except through a rework note.
+ *
+ * Takes a `current` it does not use, so the two policies read as one pair at the
+ * call sites and a future rule ("terminal rows still cannot jump to X") has a
+ * place to live.
+ */
+declare function selectableFeedbackStatuses(_current: FeedbackStatus): FeedbackStatus[];
+/**
+ * Per-category badge treatment, the counterpart to the status meta above.
+ *
+ * A category cell that is one grey pill holding the raw enum makes a CRASH —
+ * filed automatically, by somebody staring at a broken page right now — read
+ * exactly like a QUESTION, and sit unnoticed in the queue. `--danger` plus its own
+ * glyph is what makes that impossible; the hand-filed categories stay
+ * deliberately quiet so that the loud one means something.
+ *
+ * Declaration order is triage order, CRASH first.
+ */
+declare const FEEDBACK_CATEGORY_META: Record<FeedbackCategory, {
+    icon: LucideIcon;
+    badgeBg: string;
+    badgeText: string;
+}>;
+/** Triage order, CRASH first — also a category column's sort key and the option
+ *  order in its filter. Sorting by the raw enum is alphabetical, which parks
+ *  CRASH between BUG and IDEA. */
+declare const FEEDBACK_CATEGORY_ORDER: FeedbackCategory[];
+/** A category's rank for a column sort. Anything this build has never heard of —
+ *  an older client against a newer API — sorts LAST rather than to `indexOf`'s
+ *  −1, which would rank it above CRASH. */
+declare function feedbackCategoryRank(category: FeedbackCategory): number;
+/**
+ * The category as a badge.
+ *
+ * Falls back to OTHER's treatment for a category this build has never heard of,
+ * so an older client against a newer API degrades to a readable neutral pill
+ * instead of throwing on `meta.icon` — a crash report must not be able to cause
+ * one. The *label* is the caller's, and for the same reason it needs the same
+ * guard: pass what OTHER is called if you cannot name the value you were given.
+ */
+declare function FeedbackCategoryBadge({ category, label, compact, className, }: {
+    category: FeedbackCategory;
+    label: ReactNode;
+    compact?: boolean;
+    className?: string;
+}): react.JSX.Element;
+/** Where a report stands, as a badge — for the places that only *report* the
+ *  status rather than offering to change it. */
+declare function FeedbackStatusBadge({ status, label, className, }: {
+    status: FeedbackStatus;
+    label: ReactNode;
+    className?: string;
+}): react.JSX.Element;
+/**
+ * A row of statuses to switch a report to — either a table column's icon row or
+ * an expanded panel's labelled pills.
+ *
+ * One component for both, because everything except the class strings is the
+ * same decision: which one is current, and when the buttons are disabled. Two
+ * copies had already drifted — only the icon variant carried `aria-label` and
+ * `aria-pressed`, so the pill row was unlabelled for a screen reader.
+ *
+ * WHICH statuses to offer is the caller's, not this component's:
+ * {@link visibleFeedbackStatuses} for a compact column,
+ * {@link selectableFeedbackStatuses} for an expanded row. Passing the list keeps
+ * that policy readable at the two call sites instead of hiding it behind
+ * `variant`.
+ */
+declare function FeedbackStatusTransitions({ status, statuses, canEdit, onPick, variant, label, className, }: {
+    status: FeedbackStatus;
+    statuses: FeedbackStatus[];
+    canEdit: boolean;
+    onPick: (status: FeedbackStatus) => void;
+    variant: "icon" | "pill";
+    /** What each status is called, translated by the app. */
+    label: (status: FeedbackStatus) => string;
+    className?: string;
+}): react.JSX.Element;
+/**
+ * A textarea and its two buttons — for an outcome, for a note sent back with a
+ * report, for a body being corrected.
+ *
+ * One component because all three are the same gesture: a draft that is not
+ * committed until it is saved. Ctrl/⌘+Enter submits, which is the same shortcut
+ * the compose dialog next door uses, so the habit carries across the feature.
+ *
+ * ## `initial` seeds the draft; it does not own it (changed 2026-09-22)
+ *
+ * This used to re-seed from `initial` in an effect, and that effect threw away
+ * whatever was in the box — **and the picture attached to it** — every time the
+ * prop arrived with a different value. `initial` is normally the saved note, so
+ * the list refreshing under the editor, or the owner re-deriving the same string,
+ * was enough: a triager halfway through a reply, with a screenshot picked out,
+ * lost both and got the saved text back with no way to undo it.
+ *
+ * A draft belongs to the thing being edited, so switching to a different note is a
+ * different editor — say so with a `key`:
+ *
+ * ```tsx
+ * <FeedbackNoteEditor key={note.id} initial={note.body} … />
+ * ```
+ *
+ * Where the id is not in hand at the call site, pass {@link resetKey} instead and
+ * the editor re-seeds when THAT changes. Either way the decision is the caller's,
+ * which is the point: the editor cannot tell a new subject from a new render.
+ */
+declare function FeedbackNoteEditor({ initial, pending, onSave, onCancel, saveLabel, cancelLabel, placeholder, rows, attachment, resetKey, }: {
+    initial: string;
+    pending: boolean;
+    onSave: (value: string, attachment?: File | null) => void;
+    onCancel: () => void;
+    saveLabel: ReactNode;
+    cancelLabel: ReactNode;
+    /** A line above the field saying what to write, not an in-field placeholder:
+     *  a hint that disappears the moment somebody starts typing is a hint that is
+     *  gone exactly when it is being followed. */
+    placeholder?: ReactNode;
+    rows?: number;
+    /** Offer a picture with the note (Steering Design feedback #128). Omitted,
+     *  the editor is exactly the text box it always was — which is what the
+     *  *outcome* editor beside it wants, since an outcome is the answer rather
+     *  than the evidence. */
+    attachment?: FeedbackNoteAttachment;
+    /** Change this to say "the editor is now editing something ELSE", and the draft
+     *  and its attachment are dropped and re-seeded from `initial`. For call sites
+     *  that cannot put a `key` on the editor (see the note above). Leave it out and
+     *  the draft is never thrown away behind the user's back. */
+    resetKey?: string | number;
+}): react.JSX.Element;
+/** What {@link FeedbackNoteEditor} needs in order to offer a picture with the
+ *  note: the same four things {@link FeedbackAttachmentField} takes, so the
+ *  reply path is held to the app's own limits rather than to the defaults. */
+interface FeedbackNoteAttachment {
+    labels: FeedbackAttachmentLabels;
+    accept?: string[];
+    maxBytes?: number;
+    /** `info` (0.23.0) names the refused file and the limit. */
+    onError?: (kind: "type" | "size", info: FeedbackAttachmentErrorInfo) => void;
+    onCaptureScreenshot?: () => Promise<File | null>;
+}
+/**
+ * One labelled block of an opened report.
+ *
+ * The detail panel is a stack of these, and it is a stack rather than a
+ * component with fixed fields on purpose: the two apps keep a report's context
+ * and its screenshot in genuinely different places, and a shell that insisted on
+ * both would force one of them to invent a shape it does not have. What is
+ * shared is what a section *looks* like — and that is all that made the two
+ * panels read as different products.
+ */
+declare function FeedbackDetailSection({ title, action, children, }: {
+    title: ReactNode;
+    /** Something on the title's own line — an edit button, a resolved-at date. */
+    action?: ReactNode;
+    children: ReactNode;
+}): react.JSX.Element;
+/** The stack a detail panel is. Here so the spacing between sections is decided
+ *  once rather than by whichever app was written second. */
+declare function FeedbackDetail({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+/** Prose inside a section — a body, an outcome, a note.
+ *
+ *  `whitespace-pre-wrap` is the whole component: a report is written in
+ *  paragraphs, and a note appended to it later is separated by blank lines that
+ *  carry the entire "this arrived after the answer" reading. */
+declare function FeedbackProse({ children, empty }: {
+    children?: string;
+    empty?: ReactNode;
+}): react.JSX.Element;
+
+/**
+ * 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. Since
+ *  0.24.0 also the field's `buttonVariant` / `buttonSize`, for a composer whose row
+ *  wants smaller or quieter attach buttons than the bordered `md` default. */
+type FeedbackComposerAttachment = Omit<FeedbackNoteAttachment, "labels" | "onError"> & {
+    labels?: Partial<FeedbackAttachmentLabels>;
+    onError?: FeedbackAttachmentFieldSingleProps["onError"];
+} & Pick<FeedbackAttachmentFieldSingleProps, "buttonVariant" | "buttonSize">;
+/**
+ * What a render-prop {@link FeedbackComposerProps.attachmentSlot} is handed (0.24.0,
+ * keksdose).
+ *
+ * keksdose's support chat put `<FeedbackAttachmentField refs>` in the slot and a
+ * screenshot pasted into the reply box never reached it: the box is the field's
+ * sibling, so the paste bubbles to their common parent — the composer's root — and the
+ * field hears it only through `pasteFrom`, which needs that root. The composer kept it
+ * to itself, so keksdose wrapped the whole composer in a ref'd `<div>` of its own just
+ * to have an element to hand over.
+ */
+interface FeedbackComposerSlotContext {
+    /**
+     * The composer's root, round the text box and this slot — the field's `pasteFrom`,
+     * as it is: `pasteFrom={slot.root}`.
+     *
+     * A ref, not the element, because `pasteFrom` is one: the field reads `.current` in
+     * an effect, and the slot renders INSIDE this root, so the two are committed together
+     * and React attaches the root before any effect of the slot's runs — the first paste
+     * after the first paint already lands. The element itself would be `null` on the
+     * first render (it does not exist yet) and could only arrive by a second render
+     * through state; the ref is the same object every render, so the field's listener is
+     * added once and never re-added.
+     *
+     * With the built-in `attachment` on as well, it listens on this root too: hand the
+     * root to one field only, or an image pasted once is attached twice.
+     */
+    root: RefObject<HTMLElement | null>;
+    /** The composer's `pending` — a send is in flight. For the field's `disabled`
+     *  (keksdose G5b): the message carries the attachments as they were at the press. */
+    pending: boolean;
+}
+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`.
+     *
+     * A node, or (0.24.0) a function of {@link FeedbackComposerSlotContext} that returns
+     * one — for a field that wants the composer's root as its `pasteFrom`, so a
+     * screenshot pasted into the box reaches it, and `pending` for its `disabled`:
+     *
+     * ```tsx
+     * attachmentSlot={({ root, pending }) => (
+     *   <FeedbackAttachmentField refs pasteFrom={root} disabled={pending} … />
+     * )}
+     * ```
+     *
+     * Called once per render of the composer, and not at all while `disabledReason`
+     * stands in for it.
+     */
+    attachmentSlot?: ReactNode | ((slot: FeedbackComposerSlotContext) => 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;
+/** {@link FeedbackComposerSlotContext}, for {@link ChatComposer}'s `attachmentSlot`. */
+type ChatComposerSlotContext = FeedbackComposerSlotContext;
+
 /**
  * The `confirmDialog` namespace of `<UiKitProvider labels>`: the two buttons' fallback
  * text. A call that knows what it is confirming says so per call (`confirmLabel:
@@ -2116,6 +3335,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
@@ -2223,7 +3463,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, submitShortcut, submitShortcutHint, 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
@@ -2784,6 +4024,9 @@ interface UiKitLabels {
     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
@@ -2978,4 +4221,4 @@ declare function useKitFileLabels(prop?: Partial<FileLabels>): FileLabels;
  */
 declare function missingKitLabels(labels: UiKitLabelOverrides | undefined, reference: UiKitLabels): string[];
 
-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 };
+export { DEFAULT_COMMON_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 ChatComposerSlotContext as G, type ComboboxLabels as H, type CommonLabels as I, type ConfirmDialogLabels as J, type ConfirmFn as K, type ConfirmOptions as L, ConfirmProvider as M, type ConfirmProviderProps as N, type ConfirmTone as O, CopyButton as P, type CopyButtonLabels as Q, type CopyButtonProps as R, type CurrencyLabels as S, CurrentPasswordInput as T, type CurrentPasswordInputLabels as U, type CurrentPasswordInputProps as V, DEFAULT_APP_SHELL_LABELS as W, DEFAULT_ATTACHMENT_ACCEPT as X, DEFAULT_CALCULATOR_LABELS as Y, DEFAULT_CHARACTER_COUNT_LABELS as Z, DEFAULT_COMBOBOX_LABELS as _, type ButtonClassesOptions as a, FeedbackDetail as a$, DEFAULT_CONFIRM_DIALOG_LABELS as a0, DEFAULT_COPY_BUTTON_LABELS as a1, DEFAULT_CURRENCY_LABELS as a2, DEFAULT_DANGER_CONFIRM_LABELS as a3, DEFAULT_DATE_PICKER_LABELS as a4, DEFAULT_FEEDBACK_ATTACHMENT_LABELS as a5, DEFAULT_FEEDBACK_COMPOSER_LABELS as a6, DEFAULT_FEEDBACK_DIALOG_LABELS as a7, DEFAULT_FEEDBACK_THREAD_LABELS as a8, DEFAULT_FILE_LABELS as a9, FIELD_DISPLAY as aA, FIELD_FLOATING_PAD as aB, FIELD_INVALID as aC, FIELD_TRIGGER as aD, FIELD_WRITABLE_LOOK as aE, FLOATING_INPUT_CLASS as aF, FLOATING_LABEL_CLASS as aG, type FeedbackAttachmentError as aH, type FeedbackAttachmentErrorInfo as aI, FeedbackAttachmentField as aJ, type FeedbackAttachmentFieldLabels as aK, type FeedbackAttachmentFieldMultipleProps as aL, type FeedbackAttachmentFieldProps as aM, type FeedbackAttachmentFieldRefsProps as aN, type FeedbackAttachmentFieldSingleProps as aO, type FeedbackAttachmentLabels as aP, type FeedbackAttachmentRef as aQ, type FeedbackAttachmentRefsError as aR, type FeedbackCategory as aS, FeedbackCategoryBadge as aT, type FeedbackCategoryOption as aU, FeedbackComposer as aV, type FeedbackComposerAttachment as aW, type FeedbackComposerHandle as aX, type FeedbackComposerLabels as aY, type FeedbackComposerProps as aZ, type FeedbackComposerSlotContext as a_, DEFAULT_FILE_PICKER_LABELS as aa, DEFAULT_FORM_ACTIONS_LABELS as ab, DEFAULT_IBAN_INPUT_LABELS as ac, DEFAULT_MAX_ATTACHMENTS as ad, DEFAULT_MAX_ATTACHMENT_BYTES as ae, DEFAULT_MULTI_SELECT_LABELS as af, DEFAULT_PASSWORD_REVEAL_LABELS as ag, DEFAULT_PHONE_INPUT_LABELS as ah, DEFAULT_PICKER_SHEET_LABELS as ai, DEFAULT_SHARE_CARD_LABELS as aj, DEFAULT_SWIPEABLE_ROW_LABELS as ak, DEFAULT_TABS_LABELS as al, DEFAULT_TOP_BAR_LABELS as am, DangerConfirm as an, type DangerConfirmLabels as ao, type DangerConfirmProps as ap, type DangerConfirmValues as aq, type DangerConsequence as ar, type DatePickerLabels as as, EmptyState as at, type EmptyStateProps as au, FEEDBACK_CATEGORY_META as av, FEEDBACK_CATEGORY_ORDER as aw, FEEDBACK_STATUS_META as ax, FEEDBACK_STATUS_ORDER as ay, FIELD_BASE as az, type ButtonLinkProps as b, type LabelProps as b$, FeedbackDetailSection as b0, FeedbackDialog as b1, type FeedbackDialogLabels as b2, type FeedbackDialogMultipleProps as b3, type FeedbackDialogProps as b4, type FeedbackDialogSingleProps as b5, type FeedbackDialogTextLabels as b6, type FeedbackMultipleSubmission as b7, type FeedbackNoteAttachment as b8, FeedbackNoteEditor as b9, type FormActionsAlign as bA, type FormActionsDestructive as bB, type FormActionsLabels as bC, type FormActionsPlacement as bD, type FormActionsProps as bE, type FormActionsStickyWithin as bF, type FormActionsSubmitProps as bG, type FormActionsSubmitShortcut as bH, IbanInput as bI, type IbanInputLabels as bJ, type IbanInputProps as bK, IconButton as bL, type IconButtonGlyphSize as bM, type IconButtonLinkProps as bN, type IconButtonProps as bO, type IconButtonSize as bP, type IconButtonTone as bQ, type IconButtonToneColor as bR, type IconButtonVariant as bS, Input as bT, type InputProps as bU, type KitDateFormatContext as bV, type KitDateFormatter as bW, type KitLinkComponent as bX, type KitLinkProps as bY, Label as bZ, type LabelOverride as b_, FeedbackProse as ba, type FeedbackStatus as bb, FeedbackStatusBadge as bc, FeedbackStatusTransitions as bd, type FeedbackSubmission as be, FeedbackThread as bf, type FeedbackThreadAttachment as bg, type FeedbackThreadEvent as bh, type FeedbackThreadItem as bi, type FeedbackThreadLabels as bj, type FeedbackThreadMessage as bk, type FeedbackThreadProps as bl, FieldChevron as bm, type FieldChevronProps as bn, FieldHint as bo, type FieldHintProps as bp, FileButton as bq, type FileButtonProps as br, type FileLabels as bs, type FilePickerLabels as bt, type FileRejection as bu, type FileRejectionReason as bv, type FileScreenOptions as bw, FloatingField as bx, type FloatingFieldProps as by, FormActions as bz, type ButtonProps as c, type FilePickHandler as c$, type MultiSelectLabels as c0, PHONE_QUERY as c1, type PasswordRevealLabels as c2, PhoneInput as c3, type PhoneInputLabels as c4, type PhoneInputProps as c5, type PickerSheetLabels as c6, type ResponsiveFormActionsPlacement as c7, Select as c8, type SelectProps as c9, type UiKitLabelOverrides as cA, type UiKitLabels as cB, UiKitProvider as cC, type UiKitProviderProps as cD, type UseFilePickerOptions as cE, type UseFilePickerReturn as cF, buttonClasses as cG, feedbackCategoryRank as cH, formatFileSize as cI, matchesAccept as cJ, missingKitLabels as cK, nextFeedbackStatus as cL, pastedName as cM, resolvePasswordRevealLabels as cN, selectableFeedbackStatuses as cO, typedMatches as cP, useConfirm as cQ, useFilePicker as cR, useKitChartTooltipPlacement as cS, useKitDateFormatter as cT, useKitFileLabels as cU, useKitLabelOverrides as cV, useKitLabels as cW, useKitLink as cX, useKitLocale as cY, useKitWeekStart as cZ, visibleFeedbackStatuses as c_, type ShareAddRequest as ca, type ShareCandidate as cb, ShareCard as cc, type ShareCardLabels as cd, type ShareCardProps as ce, ShareDialog as cf, type ShareDialogProps as cg, type ShareGrantee as ch, SharePanel as ci, type SharePanelProps as cj, type SharePendingGrant as ck, type ShareRole as cl, Spinner as cm, type SpinnerProps as cn, type SwipeableRowLabels as co, type TabItem as cp, Tabs as cq, type TabsLabels as cr, type TabsProps as cs, Textarea as ct, type TextareaProps as cu, type TopBarLabels as cv, TypedConfirmField as cw, type TypedConfirmFieldLabels as cx, type TypedConfirmFieldProps as cy, type TypedMatch as cz, type ButtonSize as d, usePromisePending as d0, formatAccept as d1, judgePick as d2, screenFiles as d3, summariseRejections as d4, 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 };