@50arms/ui 0.0.0-stage → 35.1.0

package/dist/types/components/provenance/ConfidenceBar.d.ts

@@ -0,0 +1,118 @@
+import { type VariantProps } from "tailwind-variants";
+declare const bar: import("tailwind-variants").TVReturnType<{
+    size: {
+        xs: {
+            slot: string;
+        };
+        sm: {
+            slot: string;
+        };
+    };
+    level: {
+        1: {
+            fill: string;
+        };
+        2: {
+            fill: string;
+        };
+        3: {
+            fill: string;
+        };
+        4: {
+            fill: string;
+        };
+        5: {
+            fill: string;
+        };
+        none: {
+            slot: string;
+        };
+    };
+}, {
+    slot: string;
+    fill: string;
+}, undefined, {
+    size: {
+        xs: {
+            slot: string;
+        };
+        sm: {
+            slot: string;
+        };
+    };
+    level: {
+        1: {
+            fill: string;
+        };
+        2: {
+            fill: string;
+        };
+        3: {
+            fill: string;
+        };
+        4: {
+            fill: string;
+        };
+        5: {
+            fill: string;
+        };
+        none: {
+            slot: string;
+        };
+    };
+}, {
+    slot: string;
+    fill: string;
+}, import("tailwind-variants").TVReturnTypeLike<{
+    size: {
+        xs: {
+            slot: string;
+        };
+        sm: {
+            slot: string;
+        };
+    };
+    level: {
+        1: {
+            fill: string;
+        };
+        2: {
+            fill: string;
+        };
+        3: {
+            fill: string;
+        };
+        4: {
+            fill: string;
+        };
+        5: {
+            fill: string;
+        };
+        none: {
+            slot: string;
+        };
+    };
+}, {
+    slot: string;
+    fill: string;
+}>>;
+/** How big the bar is. See the two variants above for where each is used. */
+export type ConfidenceBarSize = NonNullable<VariantProps<typeof bar>["size"]>;
+export interface ConfidenceBarProps {
+    /** The rating itself, on `scale`. Null when nothing rated it — drawn as the empty state. */
+    rating: number | null;
+    /** The top of the scale — the "5" in "4 out of 5". */
+    scale: number;
+    /**
+     * What the rating is OF, used verbatim at the head of the accessible name and
+     * the tooltip: `"<label> 3 of 5"`.
+     *
+     * Absent means the provider's own word for it.
+     */
+    label?: string;
+    /** @default "sm" */
+    size?: ConfidenceBarSize;
+    className?: string;
+}
+export declare function ConfidenceBar({ rating, scale, label, size, className, }: ConfidenceBarProps): import("react").JSX.Element;
+export {};

package/dist/types/components/provenance/ConfidenceMeter.d.ts

@@ -0,0 +1,21 @@
+import { type ConfidenceScore } from "./types";
+export interface ConfidenceMeterProps {
+    /**
+     * A 0–1 score from `confidenceScore()`, or null when nothing scored it.
+     *
+     * Deliberately NOT a plain number — see the header. A raw literal will not
+     * type-check, which is what keeps a "4 out of 5" out of a percentage.
+     */
+    confidence: ConfidenceScore | null;
+    /**
+     * What to say when there is no score.
+     *
+     * Rendered as text rather than an empty bar, because a bar at zero and a bar
+     * with nothing to show look identical and mean opposite things.
+     */
+    unscoredLabel?: string;
+    /** Hides the band name, for dense rows where the bar is enough. */
+    compact?: boolean;
+    className?: string;
+}
+export declare function ConfidenceMeter({ confidence, unscoredLabel, compact, className, }: ConfidenceMeterProps): import("react").JSX.Element;

package/dist/types/components/provenance/ConfidenceReadout.d.ts

@@ -0,0 +1,17 @@
+import type { ProvenanceConfidence } from "./types";
+export interface ConfidenceReadoutProps {
+    confidence: ProvenanceConfidence | null;
+    /**
+     * What to say when nothing scored it. Absent means the provider's own words.
+     *
+     * Text rather than an empty bar, because a bar at zero and a bar with nothing
+     * to show look identical and mean opposite things.
+     */
+    unscoredLabel?: string;
+    /** What a RATING is of, at the head of its accessible name. Absent means the provider's own word. */
+    ratingLabel?: string;
+    /** Hides the band name on a SCORE, for dense rows where the bar is enough. */
+    compact?: boolean;
+    className?: string;
+}
+export declare function ConfidenceReadout({ confidence, unscoredLabel, ratingLabel, compact, className, }: ConfidenceReadoutProps): import("react").JSX.Element;

package/dist/types/components/provenance/ProvenanceBadge.d.ts

@@ -0,0 +1,23 @@
+import { type UiStrings } from "../../lib/i18n";
+import type { ProvenanceState } from "./types";
+/** How much of the state the badge draws. The accessible name is the same either way. */
+export type ProvenanceBadgeAppearance = "word" | "icon";
+export interface ProvenanceBadgeProps {
+    state: ProvenanceState;
+    /** Render the badge even for states that are quiet by default. */
+    alwaysShow?: boolean;
+    /**
+     * `"word"` (default) draws the icon and the word. `"icon"` draws the glyph in
+     * the same coloured box and keeps the word as visually-hidden text, so the
+     * announced name does not change.
+     *
+     * `"icon"` also lifts the quiet rule — see the note at the top of this file.
+     */
+    appearance?: ProvenanceBadgeAppearance;
+    size?: "sm" | "md";
+    className?: string;
+}
+export declare function ProvenanceBadge({ state, alwaysShow, appearance, size, className, }: ProvenanceBadgeProps): import("react").JSX.Element | null;
+/** The words this library uses for each state, from the provider's strings. Exported so a
+    consumer's own filters and legends read the same as its badges. */
+export declare function provenanceStateLabel(state: ProvenanceState, strings: UiStrings["provenanceBadge"]): string;

package/dist/types/components/provenance/ProvenanceDetail.d.ts

@@ -0,0 +1,109 @@
+import { type ReactNode } from "react";
+import type { ProvenanceRecord } from "./types";
+/** The level the field name renders at. See "NO DIALOG ASSUMPTIONS" above. */
+export type ProvenanceDetailTitleAs = "h2" | "h3" | "h4" | "h5" | "h6";
+export interface ProvenanceDetailProps {
+    record: ProvenanceRecord;
+    /**
+     * Rendered at the foot — sign-off, correction, the cited pages themselves.
+     *
+     * A slot rather than props, because the actions a consumer offers over an
+     * extracted value are theirs: this library has no idea who is allowed to sign
+     * one, or what correcting it should do. It is also where a consumer puts the
+     * evidence it had to go and FETCH — the cited pages, their thumbnails, the
+     * audit trail — none of which this library can name.
+     */
+    actions?: ReactNode;
+    /** Shown in place of the value when there is none and it did not fail. Absent means the provider's own words. */
+    emptyLabel?: string;
+    /** Shown in place of the value when the viewer may not see it. Absent means the provider's own words. */
+    redactedLabel?: string;
+    /**
+     * YOUR word for what a discrete rating is a rating OF — "Self-rated
+     * certainty", "Reviewer score" — at the head of its accessible name and
+     * tooltip.
+     *
+     * A rating is drawn as a coloured bar with no words on its face, so this is
+     * the only place its meaning is stated to a reader who stops on it. Absent
+     * means the provider's own word, the blandest true one, because a default naming
+     * anybody's domain would be a lie in everybody else's. Ignored for a
+     * continuous score, which says its own band aloud.
+     */
+    ratingLabel?: string;
+    /**
+     * Draw the VALUE yourself — an editor, most usefully.
+     *
+     * This replaces the one paragraph that prints the value, and nothing else:
+     * the field name above it, the state badge beside it, the confidence meter
+     * under it, and every row below the separator are still the component's.
+     *
+     * IT MAY BE INTERACTIVE. An `InlineEdit`, a select, a confirm/cancel pair are
+     * all legitimate — correcting a value in the surface somebody opened to judge
+     * it is the whole point of opening it, and the observed alternative is a
+     * consumer putting its editor in `actions`, which reads as "here is the
+     * value, and separately, down here, a form about some value".
+     *
+     * AN `InlineEdit` HERE STILL NEEDS THE OVERWRITE-PROTECTION CONTRACT IT
+     * SHIPS WITH (DX-2930) — this panel can stay open while the underlying
+     * record keeps changing (a re-extraction, another reviewer's own edit), so
+     * an `onCommit={(next, base) => …}` that compares `base` against whatever
+     * the caller currently believes is authoritative, plus an
+     * `onEditingChange` that suspends re-rendering `record` while someone is
+     * mid-edit, is what stops this panel from resetting a draft out from under
+     * whoever opened it. See `content/docs/provenance.mdx` for the shape.
+     *
+     * IT OVERRIDES THE ABSENCES TOO — redacted, empty and failed alike. A slot
+     * that disappeared whenever the value was missing would vanish in exactly the
+     * case a value editor is most wanted: a field that was never extracted is the
+     * one somebody actually has to type.
+     *
+     * The redaction gate cannot police a node you built yourself, so a consumer
+     * rendering this against a redactable record owns that one decision —
+     * `record.redacted` is right there to branch on.
+     *
+     * Passing `null` or `undefined` falls back to the built-in paragraph, so
+     * gating editability is `canEdit ? <Editor … /> : null` rather than two
+     * spellings of the whole component.
+     */
+    valueContent?: ReactNode;
+    /**
+     * Draw the top-right corner of the header yourself, in place of the built-in
+     * `ProvenanceBadge`.
+     *
+     * This replaces ONE thing — the badge beside the field name — and nothing
+     * else: the field name itself, `valueContent` on the line below it, and the
+     * confidence readout under that are still the component's. `ProvenanceBadge`
+     * exists because this library has an opinion about extraction verification;
+     * it has none about who ELSE has a stake in that same corner. A consumer that
+     * layers its own sign-off/attribution mark over a record — who answered,
+     * whether a human has signed it, an audit's own verdict — is naming a fact
+     * this library cannot: it owns the record's own fields, not a caller's
+     * broader authorship model. Forcing that mark one row lower (the only slot
+     * that reached the header before this one) put two badges answering related
+     * questions on two different lines instead of the one corner a reader
+     * actually scans.
+     *
+     * The SAME `??` idiom `valueContent` uses, and for the same reason: passing
+     * `null` falls back to the built-in `ProvenanceBadge` exactly as leaving the
+     * prop `undefined` does, so gating this on some later condition is
+     * `showOwnMark ? <OwnMark /> : null` rather than two spellings of the header.
+     *
+     * Does not touch the trigger — `ProvenanceDisclosure`'s closed-page mark and
+     * accessible name are unaffected either way; see `stateContent` there.
+     */
+    stateContent?: ReactNode;
+    /**
+     * Put a known id on the field-name heading, so something WRAPPING this can be
+     * labelled by it.
+     *
+     * `ProvenanceDisclosure` passes one: its popup takes `role="dialog"`, and an
+     * unlabelled dialog announces itself as nothing. An inline render normally
+     * has nothing to label and can leave this alone — a generated id is used, so
+     * the heading always has one.
+     */
+    titleId?: string;
+    /** @default "h2" */
+    titleAs?: ProvenanceDetailTitleAs;
+    className?: string;
+}
+export declare function ProvenanceDetail({ record, actions, emptyLabel, redactedLabel, ratingLabel, valueContent, stateContent, titleId, titleAs: Title, className, }: ProvenanceDetailProps): import("react").JSX.Element;

package/dist/types/components/provenance/ProvenanceDisclosure.d.ts

@@ -0,0 +1,107 @@
+import { type ReactNode } from "react";
+import type { ProvenanceRecord } from "./types";
+/** How much of the verification state the trigger draws. */
+export type ProvenanceTriggerBadge = "icon" | "word" | "none";
+export interface ProvenanceDisclosureProps {
+    record: ProvenanceRecord;
+    /** Rendered at the foot of the panel. {@link ProvenanceDetailProps.actions} */
+    actions?: ReactNode;
+    /** Shown in place of the value when there is none and it did not fail. Absent means the provider's own words. */
+    emptyLabel?: string;
+    /** Shown in place of the value when the viewer may not see it. */
+    redactedLabel?: string;
+    /** Your word for what a discrete rating is OF. {@link ProvenanceDetailProps.ratingLabel} */
+    ratingLabel?: string;
+    /**
+     * How the state reads ON THE TRIGGER. The panel always shows icon + word.
+     *
+     * - `"word"` (default) — today's behaviour exactly, quiet rule included: the
+     *   exceptions wear a worded badge and `verified` wears nothing.
+     * - `"icon"` — the glyph alone, in the same coloured box, for ALL FOUR states
+     *   including `verified`. A dense table of values wants a legend, not four
+     *   hundred sentences; the word is still announced (see below).
+     * - `"none"` — no badge at all, for a consumer drawing the state itself in an
+     *   adjacent column. The state then leaves the accessible name too, because
+     *   the name says what the trigger says and nothing more.
+     */
+    triggerBadge?: ProvenanceTriggerBadge;
+    /**
+     * Let a long value wrap onto more lines instead of truncating.
+     *
+     * Off by default because the component's home is a dense table where a
+     * ragged row height is worse than an ellipsis. On by default would be wrong;
+     * unavailable was also wrong — a value clipped at `No — typed notes only, at
+     * gu…` in a 900px column is not a value, and there was no way in.
+     */
+    valueWrap?: boolean;
+    /**
+     * Draw something else in place of the value — an id chip, an avatar, a
+     * sparkline — and anchor the panel to THAT.
+     *
+     * NOT a whole-trigger slot, and the difference matters. This node becomes the
+     * CONTENT of the disclosure's own button; the button, its focus ring, its tap
+     * target and its accessible name stay with the component. A prop that took
+     * the control itself would hand a consumer all four obligations at once, and
+     * the observed result of consumers owning this one is a chip that announces a
+     * bare id ("FM-002") with no field, no value and no state — which is the
+     * exact defect this library has now shipped three times.
+     *
+     * Pass presentational markup. An interactive element here nests a control
+     * inside a control, which is invalid and unfocusable.
+     *
+     * The field, the state and the "show where this came from" affordance are
+     * still composed around it, so the announced name is the same as any other
+     * disclosure's. The dotted underline is dropped — a chip carries its own
+     * edges and does not want a second one.
+     */
+    triggerContent?: ReactNode;
+    /**
+     * Draw the PANEL HEADER'S VALUE yourself — an editor, most usefully.
+     * {@link ProvenanceDetailProps.valueContent}
+     *
+     * It does not touch the trigger — the value on the page is still drawn from
+     * `record`, still truncated or wrapped per `valueWrap`, still announced as
+     * part of the trigger's own name. The closed page does not change because a
+     * consumer supplied this.
+     */
+    valueContent?: ReactNode;
+    /**
+     * Draw the PANEL HEADER'S top-right corner yourself, in place of the
+     * built-in `ProvenanceBadge`. {@link ProvenanceDetailProps.stateContent}
+     *
+     * Like `valueContent`, this reaches only the panel — the trigger's own
+     * `triggerBadge` is a separate, independent choice about what the CLOSED
+     * page shows, and passing this does not change it or the trigger's
+     * accessible name (see "THE NAME IS COMPUTED FROM THE CONTENT" above).
+     */
+    stateContent?: ReactNode;
+    /**
+     * Called with `true` when the panel opens and `false` when it closes.
+     *
+     * The signature `Collapsible`, `Dialog`, `Menu` and `Popover` all use, for
+     * the reason a fourth spelling would be worse than a familiar one: a
+     * consumer already knows what `onOpenChange` does everywhere else here.
+     *
+     * Purely an observation. The popover stays uncontrolled, so this does not
+     * make the caller responsible for closing it, for returning focus, or for
+     * escape — pass the callback and nothing else about the component moves.
+     *
+     * The reason it exists is the fetch: a value's citations, its source pages,
+     * its audit trail are usually a request, and this is the only moment at
+     * which a consumer knows that request is now worth making. It does NOT fire
+     * on mount — see the note at the top of this file for why that is the load-
+     * bearing half of the guarantee, not a footnote to it.
+     */
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    /**
+     * Override the panel's design width. See the `width` note at the `<Popover>`
+     * call site below for what 30rem was arithmetic on and why going wider used
+     * to read as a mistake — this exists because a real consumer's content
+     * (a dense multi-column table, not prose) outgrew that arithmetic. Unset,
+     * the panel keeps the library default of `30rem`, still clamped to
+     * `Popover`'s own viewport ceiling either way.
+     */
+    width?: string;
+}
+export declare function ProvenanceDisclosure({ record, actions, emptyLabel, redactedLabel, ratingLabel, triggerBadge, valueWrap, triggerContent, valueContent, stateContent, onOpenChange, className, width, }: ProvenanceDisclosureProps): import("react").JSX.Element;

package/dist/types/components/provenance/absence.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from "react";
+import { type IconName } from "../Icon";
+import type { UiStrings } from "../../lib/i18n";
+import type { ProvenanceRecord } from "./types";
+declare const ABSENCE: Record<"redacted" | "empty" | "failed", {
+    icon: IconName;
+    className: string;
+}>;
+export declare function Absence({ kind, children }: {
+    kind: keyof typeof ABSENCE;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Whether the record is withheld from this viewer. The first gate, everywhere. */
+export declare function isRedacted(record: ProvenanceRecord): boolean;
+/**
+ * Whether the record's own check disproved it.
+ *
+ * Precedence matters and is asserted: a record that is BOTH withheld and failed
+ * reads as withheld, because that is the fact about this viewer. The failure is
+ * still true, but it is not theirs to act on — and showing them a failure reason
+ * drawn from a value they may not see is the leak the panel is supposed to
+ * close.
+ */
+export declare function isFailed(record: ProvenanceRecord): boolean;
+/**
+ * What a reader is shown IN PLACE OF the value — or the value itself.
+ *
+ * Each of the three absences says which one it is: withheld from you, never
+ * extracted, or extracted and disproved. Rendering all three as an empty cell
+ * would make them indistinguishable, and they call for completely different
+ * next actions.
+ */
+export declare function shownValue(record: ProvenanceRecord, { emptyLabel, redactedLabel }: {
+    emptyLabel?: string;
+    redactedLabel?: string;
+}, absence: UiStrings["provenanceAbsence"]): ReactNode;
+export {};

package/dist/types/components/provenance/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./ConfidenceMeter";
+export * from "./ConfidenceReadout";
+export * from "./ConfidenceBar";
+export * from "./ProvenanceBadge";
+export * from "./ProvenanceDetail";
+export * from "./ProvenanceDisclosure";

package/dist/types/components/provenance/types.d.ts

@@ -0,0 +1,137 @@
+import type { ReactNode } from "react";
+export type ProvenanceState = 
+/** Machine-extracted, and the check passed. */
+"verified"
+/** A person signed it — on top of the machine's verdict, never instead. */
+ | "human"
+/** Extracted, but nothing confirmed it. The value stands, flagged. */
+ | "unverified"
+/** The check actively failed. There is no value. */
+ | "failed";
+/** Where a value came from, precisely enough to go and look. */
+export interface ProvenanceSource {
+    /** The thing it came from — a document title, a URL, a table name. */
+    label: string;
+    /** Where inside it: "page 4", "line 82", "§3.1". Null when there is no locus. */
+    locus: string | null;
+    /** The exact text at that locus. */
+    quote: string | null;
+}
+/**
+ * The verdict of whatever check the consumer ran.
+ *
+ * `passed` is a tri-state on purpose: `true`, `false`, and `null` for "no check
+ * was run" — which is a different claim from "a check ran and failed", and
+ * collapsing the two would let an unchecked value read as a passing one.
+ */
+export interface ProvenanceCheck {
+    passed: boolean | null;
+    /** How it was checked, or why it could not be. */
+    detail: string;
+}
+/** The model call that produced the value. */
+export interface ProvenanceCall {
+    model: string;
+    tokensIn: number;
+    tokensOut: number;
+    latencyMs: number;
+}
+/** A person's signature over the value. */
+export interface ProvenanceSignoff {
+    by: string;
+    at: string;
+    note: string | null;
+    /**
+     * What the value was before they changed it.
+     *
+     * Null when they signed without correcting. Present means the value was
+     * replaced — and the original is kept, because a correction whose previous
+     * value is gone is an assertion rather than a record.
+     */
+    replaced: string | null;
+}
+export interface ProvenanceRecord {
+    /** What this value IS. Always shown, even when the value is hidden. */
+    label: string;
+    /** Null when it failed, or when the viewer may not see it. */
+    value: ReactNode | null;
+    state: ProvenanceState;
+    /**
+     * How sure the author was, on whichever scale they said it — `scoredConfidence`
+     * for a continuous 0–1 figure, `ratedConfidence` for "4 out of 5". Null when
+     * nothing scored it, which is a different claim from a score of zero.
+     */
+    confidence: ProvenanceConfidence | null;
+    source: ProvenanceSource | null;
+    reasoning: string | null;
+    check: ProvenanceCheck | null;
+    call: ProvenanceCall | null;
+    signoff: ProvenanceSignoff | null;
+    /**
+     * Withheld from this viewer.
+     *
+     * Distinct from a null value: the label and the verification state still
+     * render, so a reader can see that a value EXISTS and was checked without
+     * seeing it. Hiding the row entirely would make the record look thinner than
+     * it is to the person least able to tell.
+     */
+    redacted?: boolean;
+}
+declare const CONFIDENCE_SCORE: unique symbol;
+/**
+ * A confidence on the CONTINUOUS 0–1 scale — the one thing that may be drawn as
+ * a percentage.
+ *
+ * Nominal on purpose. It IS a number at runtime and arithmetic on it behaves
+ * exactly as it reads, but a raw `0.94` is not assignable to it. `confidenceScore`
+ * is the only way in, and is therefore the one place a range can be checked.
+ */
+export type ConfidenceScore = number & {
+    readonly [CONFIDENCE_SCORE]: "score";
+};
+/**
+ * Mint a 0–1 score.
+ *
+ * Out of range is CLAMPED and warned about rather than thrown: the caller most
+ * likely to be out of range is one holding a rating on some other scale, and a
+ * blank page is a worse outcome than a bar at one end with a line in the console
+ * naming the function that fixes it.
+ */
+export declare function confidenceScore(value: number): ConfidenceScore;
+/**
+ * HOW SURE THE AUTHOR WAS, carrying WHICH KIND OF SCALE it was said on.
+ *
+ * Never written as a literal — see the brand above. `scoredConfidence` and
+ * `ratedConfidence` are the two doors, and which door a value came through is
+ * what the renderer dispatches on.
+ */
+export type ProvenanceConfidence = 
+/** Continuous 0–1. Drawn as a banded meter with its percentage. */
+{
+    readonly kind: "score";
+    readonly score: ConfidenceScore;
+}
+/**
+ * `rating` out of `scale`, both whole numbers. Drawn as one bar — one colour per
+ * step of five — because a percentage of a small scale prints precision it
+ * does not have.
+ */
+ | {
+    readonly kind: "rating";
+    readonly rating: number;
+    readonly scale: number;
+};
+/** A continuous 0–1 confidence, for a record. */
+export declare function scoredConfidence(value: number): ProvenanceConfidence;
+/**
+ * A discrete `rating` out of `scale`, for a record.
+ *
+ * The denominator travels WITH the number, because "4" means nothing on its own
+ * and every consumer that has had to pass a rating around without one has ended
+ * up hard-coding the scale at the far end.
+ */
+export declare function ratedConfidence(rating: number, scale: number): ProvenanceConfidence;
+/** 0..1 to a band. A bare percentage invites false precision. */
+export type ConfidenceBand = "high" | "moderate" | "low";
+export declare function confidenceBand(confidence: ConfidenceScore): ConfidenceBand;
+export {};

package/dist/types/components/rbac/AccessRequestPanel.d.ts

@@ -0,0 +1,92 @@
+import { type ReactNode } from "react";
+import type { AccessRequestKind } from "../../lib/i18n/areas/rbac";
+import { type ExpiredNote, type AccessRequestState } from "./approvalPanelParts";
+import type { Permission, Role } from "./types";
+/** DXUI-15: `machine` is a dev machine's unattended maintenance: a fixed read-only grant, so no role is chosen. */
+export type { AccessRequestKind };
+export type { AccessRequestState, ExpiredNote };
+export interface AccessRequest {
+    kind: AccessRequestKind;
+    /** The session title or the worker id: what the requester calls itself. */
+    label: string;
+    repo?: string;
+    machine?: string;
+    /** The address the request came from. */
+    requesterIp?: string;
+    clientVersion?: string;
+    /** ISO instant. */
+    requestedAt: string;
+    /** ISO instant. Shown while the request is pending. */
+    expiresAt?: string;
+    /** The short code the requester also displays. Compared by eye, or typed back when `confirmCodeEntry` is set. */
+    confirmCode: string;
+    /** The label of the role granted. Shown once the request is approved or claimed. */
+    roleLabel?: string;
+}
+/**
+ * DX-4856: the key a claim minted, and what a person may do with it. Pass it once the requester holds a key; omit it before that.
+ * `revokedAt` set means the key was revoked: the panel reads Revoked and offers nothing. Otherwise `onRevoke` (pass it only for a
+ * person allowed to revoke this key) adds a Revoke key button behind a confirmation dialog.
+ */
+export interface IssuedKey {
+    /** ISO instant the key was revoked. */
+    revokedAt?: string;
+    /** Who revoked it, when a person did. */
+    revokedBy?: string;
+    /** Revokes the key. A rejection shows its message in the panel; a resolution leaves the panel as it was until the consumer hands it `revokedAt`. */
+    onRevoke?: () => Promise<void>;
+}
+interface AccessRequestPanelCommonProps {
+    state: AccessRequestState;
+    onDeny: () => Promise<void>;
+    /**
+     * Why an expired request expired and what its requester does next. Used only in the `expired` state; without it the readout says only
+     * that nothing was granted.
+     */
+    expiredNote?: ExpiredNote;
+    /**
+     * Opt in to typing the confirm code instead of comparing it by eye: the code is not rendered, a field takes it, and Approve is
+     * disabled until what was typed matches `request.confirmCode`, ignoring case and spaces. Deny stays available.
+     */
+    confirmCodeEntry?: boolean;
+    /** DX-4856: the key this request minted, with its revoke. Used only in the `claimed` state. */
+    issuedKey?: IssuedKey;
+    /**
+     * DXUI-95: the consumer's own control, drawn just above the Approve and Deny buttons while `state` is `pending`, on role and
+     * machine requests alike (for example a switch for machine auto-approve). Never rendered in a terminal state. The panel
+     * knows nothing of what it holds.
+     */
+    aboveActions?: ReactNode;
+    className?: string;
+}
+/** A session or worker request: the approver chooses the role the key gets. */
+export interface RoleAccessRequestPanelProps extends AccessRequestPanelCommonProps {
+    request: AccessRequest & {
+        kind: "session" | "worker";
+    };
+    /** The roles the approver may grant. */
+    roles: Role[];
+    /** The permission catalog, used to name the permissions that make a role unavailable. */
+    permissions: Permission[];
+    /** What the approver holds. A role holding anything outside this set cannot be chosen. */
+    ownPermissionKeys: string[];
+    /**
+     * The role to start on instead of the narrowest allowed one (DX-4431: an agent session starts on the team's
+     * default agent role). Used only while it is selectable; otherwise the narrowest allowed role applies.
+     */
+    defaultRoleId?: string;
+    onApprove: (roleId: string) => Promise<void>;
+}
+/** DXUI-15: a machine request has a fixed read-only grant, so there is no role to choose and the role props are never read. */
+export interface MachineAccessRequestPanelProps extends AccessRequestPanelCommonProps {
+    request: AccessRequest & {
+        kind: "machine";
+    };
+    roles?: Role[];
+    permissions?: Permission[];
+    ownPermissionKeys?: string[];
+    defaultRoleId?: string;
+    onApprove: () => Promise<void>;
+}
+export type AccessRequestPanelProps = RoleAccessRequestPanelProps | MachineAccessRequestPanelProps;
+export declare function AccessRequestPanel(props: AccessRequestPanelProps): import("react").JSX.Element;