@eifi1/ui-kit 0.23.0 → 0.24.1

package/dist/{feedback-BxeQVzwq.d.ts → feedback-DOwPu-Il.d.ts}

@@ -1,7 +1,5 @@
-import { l as FeedbackAttachmentLabels, k as FeedbackAttachmentFieldSingleProps, g as FeedbackAttachmentFieldLabels, u as FeedbackDialogTextLabels } from './feedback-attachment-fGAzZPf0.js';
-import { FeedbackNoteAttachment } from './feedback/feedback-inbox.js';
 import * as react from 'react';
-import { 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';
@@ -25,13 +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 { 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';
@@ -1531,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;
@@ -1574,9 +1656,10 @@ 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 is held
- * 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
@@ -1584,8 +1667,10 @@ interface DangerConfirmProps extends Omit<ComponentPropsWithoutRef<"div">, "onCh
  * “DELETE” to confirm", "Tick the box to confirm", "Enter your password to confirm";
  * `labels.needs*`), the first open guard in the order they are drawn. FormActions'
  * `submitDisabledReason` does the same for a form's Save. Pressing it, or Enter in a
- * field, does nothing. A lock's reason wins over a guard's; while the action runs the
- * confirm is plainly disabled, its spinner saying why.
+ * 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
@@ -1597,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
@@ -1827,6 +1912,732 @@ 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.
@@ -1976,11 +2787,45 @@ declare function FeedbackThread({ messages, loading, empty, renderAttachment, re
 /** 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. */
+ *  (`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
@@ -2004,8 +2849,21 @@ interface FeedbackComposerProps {
      * 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;
+    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`
@@ -2135,6 +2993,8 @@ 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
@@ -3361,4 +4221,4 @@ declare function useKitFileLabels(prop?: Partial<FileLabels>): FileLabels;
  */
 declare function missingKitLabels(labels: UiKitLabelOverrides | undefined, reference: UiKitLabels): string[];
 
-export { DEFAULT_COPY_BUTTON_LABELS as $, type AppShellLabels as A, Button as B, type CalculatorLabels as C, type ChatComposerHandle as D, type ChatComposerLabels as E, type ChatComposerProps as F, type ComboboxLabels as G, type CommonLabels as H, type ConfirmDialogLabels as I, type ConfirmFn as J, type ConfirmOptions as K, ConfirmProvider as L, type ConfirmProviderProps as M, type ConfirmTone as N, CopyButton as O, type CopyButtonLabels as P, type CopyButtonProps as Q, type CurrencyLabels as R, CurrentPasswordInput as S, type CurrentPasswordInputLabels as T, type CurrentPasswordInputProps as U, DEFAULT_APP_SHELL_LABELS as V, DEFAULT_CALCULATOR_LABELS as W, DEFAULT_CHARACTER_COUNT_LABELS as X, DEFAULT_COMBOBOX_LABELS as Y, DEFAULT_COMMON_LABELS as Z, DEFAULT_CONFIRM_DIALOG_LABELS as _, type ButtonClassesOptions as a, type FormActionsProps as a$, DEFAULT_CURRENCY_LABELS as a0, DEFAULT_DANGER_CONFIRM_LABELS as a1, DEFAULT_DATE_PICKER_LABELS as a2, DEFAULT_FEEDBACK_COMPOSER_LABELS as a3, DEFAULT_FEEDBACK_THREAD_LABELS as a4, DEFAULT_FILE_LABELS as a5, DEFAULT_FILE_PICKER_LABELS as a6, DEFAULT_FORM_ACTIONS_LABELS as a7, DEFAULT_IBAN_INPUT_LABELS as a8, DEFAULT_MULTI_SELECT_LABELS as a9, type FeedbackComposerLabels as aA, type FeedbackComposerProps as aB, FeedbackThread as aC, type FeedbackThreadAttachment as aD, type FeedbackThreadEvent as aE, type FeedbackThreadItem as aF, type FeedbackThreadLabels as aG, type FeedbackThreadMessage as aH, type FeedbackThreadProps as aI, FieldChevron as aJ, type FieldChevronProps as aK, FieldHint as aL, type FieldHintProps as aM, FileButton as aN, type FileButtonProps as aO, type FileLabels as aP, type FilePickerLabels as aQ, type FileRejection as aR, type FileRejectionReason as aS, type FileScreenOptions as aT, FloatingField as aU, type FloatingFieldProps as aV, FormActions as aW, type FormActionsAlign as aX, type FormActionsDestructive as aY, type FormActionsLabels as aZ, type FormActionsPlacement as a_, DEFAULT_PASSWORD_REVEAL_LABELS as aa, DEFAULT_PHONE_INPUT_LABELS as ab, DEFAULT_PICKER_SHEET_LABELS as ac, DEFAULT_SHARE_CARD_LABELS as ad, DEFAULT_SWIPEABLE_ROW_LABELS as ae, DEFAULT_TABS_LABELS as af, DEFAULT_TOP_BAR_LABELS as ag, DangerConfirm as ah, type DangerConfirmLabels as ai, type DangerConfirmProps as aj, type DangerConfirmValues as ak, type DangerConsequence as al, type DatePickerLabels as am, EmptyState as an, type EmptyStateProps as ao, FIELD_BASE as ap, FIELD_DISPLAY as aq, FIELD_FLOATING_PAD as ar, FIELD_INVALID as as, FIELD_TRIGGER as at, FIELD_WRITABLE_LOOK as au, FLOATING_INPUT_CLASS as av, FLOATING_LABEL_CLASS as aw, FeedbackComposer as ax, type FeedbackComposerAttachment as ay, type FeedbackComposerHandle as az, type ButtonLinkProps as b, type UseFilePickerOptions as b$, type FormActionsStickyWithin as b0, type FormActionsSubmitProps as b1, type FormActionsSubmitShortcut as b2, IbanInput as b3, type IbanInputLabels as b4, type IbanInputProps as b5, IconButton as b6, type IconButtonGlyphSize as b7, type IconButtonLinkProps as b8, type IconButtonProps as b9, type ShareCardLabels as bA, type ShareCardProps as bB, ShareDialog as bC, type ShareDialogProps as bD, type ShareGrantee as bE, SharePanel as bF, type SharePanelProps as bG, type SharePendingGrant as bH, type ShareRole as bI, Spinner as bJ, type SpinnerProps as bK, type SwipeableRowLabels as bL, type TabItem as bM, Tabs as bN, type TabsLabels as bO, type TabsProps as bP, Textarea as bQ, type TextareaProps as bR, type TopBarLabels as bS, TypedConfirmField as bT, type TypedConfirmFieldLabels as bU, type TypedConfirmFieldProps as bV, type TypedMatch as bW, type UiKitLabelOverrides as bX, type UiKitLabels as bY, UiKitProvider as bZ, type UiKitProviderProps as b_, type IconButtonSize as ba, type IconButtonTone as bb, type IconButtonToneColor as bc, type IconButtonVariant as bd, Input as be, type InputProps as bf, type KitDateFormatContext as bg, type KitDateFormatter as bh, type KitLinkComponent as bi, type KitLinkProps as bj, Label as bk, type LabelOverride as bl, type LabelProps as bm, type MultiSelectLabels as bn, PHONE_QUERY as bo, type PasswordRevealLabels as bp, PhoneInput as bq, type PhoneInputLabels as br, type PhoneInputProps as bs, type PickerSheetLabels as bt, type ResponsiveFormActionsPlacement as bu, Select as bv, type SelectProps as bw, type ShareAddRequest as bx, type ShareCandidate as by, ShareCard as bz, type ButtonProps as c, type UseFilePickerReturn as c0, buttonClasses as c1, formatFileSize as c2, matchesAccept as c3, missingKitLabels as c4, resolvePasswordRevealLabels as c5, typedMatches as c6, useConfirm as c7, useFilePicker as c8, useKitChartTooltipPlacement as c9, useKitDateFormatter as ca, useKitFileLabels as cb, useKitLabelOverrides as cc, useKitLabels as cd, useKitLink as ce, useKitLocale as cf, useKitWeekStart as cg, type FilePickHandler as ch, usePromisePending as ci, formatAccept as cj, judgePick as ck, screenFiles as cl, summariseRejections as cm, type ButtonSize as d, type ButtonTone as e, type ButtonVariant as f, Card as g, CardAction as h, type CardActionProps as i, CardContent as j, type CardContentProps as k, type CardDensity as l, CardDescription as m, type CardDescriptionProps as n, CardFooter as o, type CardFooterProps as p, CardHeader as q, type CardHeaderProps as r, type CardProps as s, CardTitle as t, type CardTitleLevel as u, type CardTitleProps as v, type CardTone as w, type CharacterCountLabels as x, type ChartTooltipPlacement as y, ChatComposer as z };
+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 };