@agentconsent/react 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1047 @@
+import * as React from 'react';
+
+/**
+ * Action Preview — show exactly what an agent is about to do before it
+ * executes, and collect an explicit approve/reject decision.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * Two render modes:
+ * - inline (default): a card inside the conversation/task surface
+ * - modal (`asModal`): a Radix AlertDialog — focus is trapped, initial
+ *   focus lands on the reject (least destructive) action, and Escape
+ *   rejects. Modal mode is controlled via `open` / `onOpenChange`.
+ */
+type ActionPreviewConsequence = "reversible" | "irreversible";
+interface ActionPreviewRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+    /** Called when the user approves the action. */
+    onApprove: () => void;
+    /** Called when the user rejects the action (button, or Escape in modal mode). */
+    onReject: () => void;
+    /**
+     * How hard the action is to undo. Irreversible consequence shifts the
+     * approve button to destructive styling and changes nothing else —
+     * friction weighting beyond that belongs to the Irreversibility Gate
+     * pattern.
+     */
+    consequence?: ActionPreviewConsequence;
+    /** Render as a modal AlertDialog instead of an inline card. */
+    asModal?: boolean;
+    /** Modal mode only: whether the dialog is open (controlled). */
+    open?: boolean;
+    /** Modal mode only: called when the dialog requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+type ActionPreviewHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$b(props: ActionPreviewHeaderProps): React.JSX.Element;
+type ActionPreviewIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$b(props: ActionPreviewIconProps): React.JSX.Element;
+type ActionPreviewTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The action, stated as a verb phrase: "Send email to Dana Ito". */
+declare function Title$b(props: ActionPreviewTitleProps): React.JSX.Element;
+type ActionPreviewFieldsProps = React.HTMLAttributes<HTMLDListElement>;
+declare function Fields(props: ActionPreviewFieldsProps): React.JSX.Element;
+interface ActionPreviewFieldProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The fact's name: "To", "Amount", "File". */
+    label: React.ReactNode;
+    /** The fact's exact value — never a summary. */
+    children: React.ReactNode;
+}
+declare function Field({ label, children, ...rest }: ActionPreviewFieldProps): React.JSX.Element;
+interface ActionPreviewContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Toggle label: "Message body", "Full diff". */
+    label: React.ReactNode;
+    defaultExpanded?: boolean;
+    children: React.ReactNode;
+}
+declare function Content({ label, defaultExpanded, children, ...rest }: ActionPreviewContentProps): React.JSX.Element;
+interface ActionPreviewSourceProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The agent requesting approval: "Inbox Assistant". */
+    agent: React.ReactNode;
+    /** The authority it acts under: task name, grant, or trigger. */
+    authority?: React.ReactNode;
+}
+declare function Source$1({ agent, authority, children, ...rest }: ActionPreviewSourceProps): React.JSX.Element;
+type ActionPreviewActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$8(props: ActionPreviewActionsProps): React.JSX.Element;
+type ActionPreviewButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ActionPreview: {
+    Root: React.ForwardRefExoticComponent<ActionPreviewRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$b;
+    Icon: typeof Icon$b;
+    Title: typeof Title$b;
+    Fields: typeof Fields;
+    Field: typeof Field;
+    Content: typeof Content;
+    Source: typeof Source$1;
+    Actions: typeof Actions$8;
+    Approve: React.ForwardRefExoticComponent<ActionPreviewButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    Reject: React.ForwardRefExoticComponent<ActionPreviewButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Irreversibility Gate — a confirmation whose friction scales with the
+ * consequence of the action. Reversible actions confirm in a click;
+ * irreversible ones require a deliberate, legible gesture.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * The friction ladder is driven by `severity`:
+ * - "reversible": confirm is enabled immediately, neutral styling.
+ * - "undoable": confirm is enabled, but the gate advertises the undo
+ *   window so the user knows the action is recoverable.
+ * - "irreversible": confirm styling turns destructive, and — when a
+ *   `confirmPhrase` is supplied — stays disabled until the user types
+ *   that exact phrase. Type-to-confirm is the accessible, deliberate
+ *   alternative to hold-to-confirm (which is invisible to screen readers
+ *   and punishing for motor impairments).
+ *
+ * Two render modes mirror Action Preview:
+ * - inline (default): a `role="group"` card
+ * - modal (`asModal`): a Radix AlertDialog — focus is trapped, initial
+ *   focus lands on cancel (the least destructive action), and Escape
+ *   cancels. Controlled via `open` / `onOpenChange`.
+ */
+type IrreversibilitySeverity = "reversible" | "undoable" | "irreversible";
+interface IrreversibilityGateRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+    /** Called when the user confirms the action. */
+    onConfirm: () => void;
+    /** Called when the user backs out (button, or Escape in modal mode). */
+    onCancel: () => void;
+    /**
+     * How hard the action is to undo. Scales the gate's friction and the
+     * confirm button's styling. Defaults to "irreversible" — the case this
+     * pattern exists for.
+     */
+    severity?: IrreversibilitySeverity;
+    /**
+     * When set and `severity` is "irreversible", the confirm action stays
+     * disabled until the user types this exact phrase. Ignored at lower
+     * severities, where type-to-confirm would be gratuitous friction.
+     */
+    confirmPhrase?: string;
+    /** Render as a modal AlertDialog instead of an inline card. */
+    asModal?: boolean;
+    /** Modal mode only: whether the dialog is open (controlled). */
+    open?: boolean;
+    /** Modal mode only: called when the dialog requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+type IrreversibilityGateHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$a(props: IrreversibilityGateHeaderProps): React.JSX.Element;
+type IrreversibilityGateIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$a(props: IrreversibilityGateIconProps): React.JSX.Element;
+type IrreversibilityGateTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The action, stated as a verb phrase: "Delete 1,240 files". */
+declare function Title$a(props: IrreversibilityGateTitleProps): React.JSX.Element;
+type IrreversibilityGateDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+/** One line of framing above the enumerated consequences. */
+declare function Description$7(props: IrreversibilityGateDescriptionProps): React.JSX.Element;
+type IrreversibilityGateConsequencesProps = React.HTMLAttributes<HTMLUListElement>;
+declare function Consequences(props: IrreversibilityGateConsequencesProps): React.JSX.Element;
+type IrreversibilityGateConsequenceProps = React.LiHTMLAttributes<HTMLLIElement>;
+/** One concrete, specific effect: "Permanently deletes 1,240 files". */
+declare function Consequence$1({ children, ...rest }: IrreversibilityGateConsequenceProps): React.JSX.Element;
+type IrreversibilityGateConfirmFieldProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "id">;
+/**
+ * The type-to-confirm input. Renders only when the gate actually requires
+ * a phrase (severity "irreversible" + a `confirmPhrase`); otherwise it
+ * renders nothing, so demos can leave it in the tree unconditionally.
+ */
+declare function ConfirmField({ children, ...rest }: IrreversibilityGateConfirmFieldProps & {
+    children?: React.ReactNode;
+}): React.JSX.Element | null;
+type IrreversibilityGateActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$7(props: IrreversibilityGateActionsProps): React.JSX.Element;
+type IrreversibilityGateButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const IrreversibilityGate: {
+    Root: React.ForwardRefExoticComponent<IrreversibilityGateRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$a;
+    Icon: typeof Icon$a;
+    Title: typeof Title$a;
+    Description: typeof Description$7;
+    Consequences: typeof Consequences;
+    Consequence: typeof Consequence$1;
+    ConfirmField: typeof ConfirmField;
+    Actions: typeof Actions$7;
+    Confirm: React.ForwardRefExoticComponent<IrreversibilityGateButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    Cancel: React.ForwardRefExoticComponent<IrreversibilityGateButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Scoped Grant — the consent screen for connecting an agent to a service.
+ * Where an OAuth scope list says "access your email", this pattern makes the
+ * capability granularity legible: which resources, and read vs. write vs.
+ * delete, each as an individually reviewable, toggleable permission.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * Selection is a set of granted scope ids, controllable via `value` /
+ * `onValueChange` or uncontrolled via `defaultValue`. Mandatory scopes are
+ * declared once at the root (`requiredScopes`) so the grant payload has a
+ * single source of truth and children never need to self-register.
+ */
+type ScopeAccess = "read" | "write" | "delete";
+interface ScopedGrantRootProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    /** Granted scope ids (controlled). */
+    value?: string[];
+    /** Initial granted scope ids (uncontrolled). */
+    defaultValue?: string[];
+    /** Called whenever the granted set changes. */
+    onValueChange?: (ids: string[]) => void;
+    /**
+     * Scope ids that are mandatory for the connection to function. They are
+     * always granted, render as locked, and are always present in the grant
+     * payload — declared here so payload/count have one source of truth.
+     */
+    requiredScopes?: string[];
+    /** Called with the final granted ids when the user confirms the grant. */
+    onGrant: (ids: string[]) => void;
+    /** Called when the user declines to connect. */
+    onCancel?: () => void;
+    children: React.ReactNode;
+}
+type ScopedGrantHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$9(props: ScopedGrantHeaderProps): React.JSX.Element;
+type ScopedGrantIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$9(props: ScopedGrantIconProps): React.JSX.Element;
+type ScopedGrantTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** What is being connected to what: "Connect Inbox Assistant to Gmail". */
+declare function Title$9(props: ScopedGrantTitleProps): React.JSX.Element;
+type ScopedGrantDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function Description$6(props: ScopedGrantDescriptionProps): React.JSX.Element;
+interface ScopedGrantGroupProps extends Omit<React.FieldsetHTMLAttributes<HTMLFieldSetElement>, "resource"> {
+    /** The resource this cluster of scopes applies to: "Gmail". */
+    label: React.ReactNode;
+    /** How the resource is narrowed: "Board 2026 label only". */
+    resource?: React.ReactNode;
+}
+/**
+ * Clusters scopes by the resource they touch, so "read" against one folder
+ * and "delete" against the whole account are never conflated. Renders a
+ * fieldset/legend so assistive tech announces the grouping.
+ */
+declare function Group({ label, resource, children, ...rest }: ScopedGrantGroupProps): React.JSX.Element;
+interface ScopedGrantScopeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "id"> {
+    /** Stable id used in the granted set and `requiredScopes`. */
+    id: string;
+    /** Power level of this capability — surfaced as a text badge, never color alone. */
+    access: ScopeAccess;
+    /** Plain-language capability name: "Send messages on your behalf". */
+    label: React.ReactNode;
+    /** What granting it actually lets the agent do. */
+    description?: React.ReactNode;
+}
+declare function Scope$1({ id, access, label, description, ...rest }: ScopedGrantScopeProps): React.JSX.Element;
+type ScopedGrantActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$6(props: ScopedGrantActionsProps): React.JSX.Element;
+interface ScopedGrantGrantProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    /**
+     * Button content. As a render function it receives the live grant count,
+     * so the label can read "Grant 3 permissions" without lifting state.
+     */
+    children: React.ReactNode | ((state: {
+        count: number;
+    }) => React.ReactNode);
+}
+type ScopedGrantCancelProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ScopedGrant: {
+    Root: React.ForwardRefExoticComponent<ScopedGrantRootProps & React.RefAttributes<HTMLFormElement>>;
+    Header: typeof Header$9;
+    Icon: typeof Icon$9;
+    Title: typeof Title$9;
+    Description: typeof Description$6;
+    Group: typeof Group;
+    Scope: typeof Scope$1;
+    Actions: typeof Actions$6;
+    Grant: React.ForwardRefExoticComponent<ScopedGrantGrantProps & React.RefAttributes<HTMLButtonElement>>;
+    Cancel: React.ForwardRefExoticComponent<ScopedGrantCancelProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+interface ProgressiveScopeRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+    /** Power level of the newly requested capability — surfaced as a text badge. */
+    access?: ScopeAccess;
+    /** Grant the capability for only the blocked action. */
+    onAllowOnce: () => void;
+    /** Escalate the capability into the standing grant. */
+    onAllowAlways: () => void;
+    /** Refuse the escalation (button, or Escape in modal mode). */
+    onDeny: () => void;
+    /** Render as a modal AlertDialog instead of an inline card. */
+    asModal?: boolean;
+    /** Modal mode only: whether the dialog is open (controlled). */
+    open?: boolean;
+    /** Modal mode only: called when the dialog requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+type ProgressiveScopeHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$8(props: ProgressiveScopeHeaderProps): React.JSX.Element;
+type ProgressiveScopeIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$8(props: ProgressiveScopeIconProps): React.JSX.Element;
+type ProgressiveScopeTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The ask, stated plainly: "Inbox Assistant needs to send email". */
+declare function Title$8(props: ProgressiveScopeTitleProps): React.JSX.Element;
+type ProgressiveScopeReasonProps = React.HTMLAttributes<HTMLParagraphElement>;
+/**
+ * Why the agent is asking now — tied to the concrete, blocked action.
+ * "To reply to the vendor, it needs to send email on your behalf."
+ */
+declare function Reason(props: ProgressiveScopeReasonProps): React.JSX.Element;
+interface ProgressiveScopeRequestProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Plain-language capability being requested: "Send email on your behalf". */
+    label: React.ReactNode;
+    /** What granting it lets the agent do. */
+    description?: React.ReactNode;
+}
+declare function Request({ label, description, ...rest }: ProgressiveScopeRequestProps): React.JSX.Element;
+type ProgressiveScopeCurrentProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * Frames the escalation as additive by naming the standing grant it builds
+ * on: "Inbox Assistant can already read this label."
+ */
+declare function Current({ children, ...rest }: ProgressiveScopeCurrentProps): React.JSX.Element;
+type ProgressiveScopeActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$5(props: ProgressiveScopeActionsProps): React.JSX.Element;
+type ProgressiveScopeButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ProgressiveScope: {
+    Root: React.ForwardRefExoticComponent<ProgressiveScopeRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$8;
+    Icon: typeof Icon$8;
+    Title: typeof Title$8;
+    Reason: typeof Reason;
+    Request: typeof Request;
+    Current: typeof Current;
+    Actions: typeof Actions$5;
+    AllowOnce: React.ForwardRefExoticComponent<ProgressiveScopeButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    AllowAlways: React.ForwardRefExoticComponent<ProgressiveScopeButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    Deny: React.ForwardRefExoticComponent<ProgressiveScopeButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Batch Approval — a review queue for a run of agent-proposed actions.
+ * Reviewing agent work one modal at a time causes approval fatigue: the user
+ * falls into a rhythm and starts rubber-stamping. Batch Approval gives the
+ * queue triage affordances — select many, approve or reject as a group — while
+ * deliberately refusing to let the highest-stakes items be swept up in a bulk
+ * "approve all".
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * The queue is declared once at the root (`items`) so selection eligibility
+ * and counts have a single source of truth — mirroring Scoped Grant's
+ * `requiredScopes`. An item flagged `requiresReview` is excluded from
+ * select-all and from batch actions: it can only be approved or rejected
+ * on its own row, so the item that most needs a human never gets a group pass.
+ *
+ * Selection is a set of item ids, controllable via `value` / `onValueChange`
+ * or uncontrolled via `defaultValue`.
+ */
+interface BatchApprovalItem {
+    /** Stable id used in the selection set and in approve/reject payloads. */
+    id: string;
+    /**
+     * When true the item is high-stakes: it is never selectable in bulk and is
+     * excluded from select-all and the batch actions. It must be decided on its
+     * own row. Irreversible or ambiguous actions belong here.
+     */
+    requiresReview?: boolean;
+}
+interface BatchApprovalRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+    /**
+     * The queue, declared once so selection eligibility and counts have one
+     * source of truth. Order is presentation-only; children still render each
+     * row. Items marked `requiresReview` are excluded from bulk selection.
+     */
+    items: BatchApprovalItem[];
+    /** Selected item ids (controlled). */
+    value?: string[];
+    /** Initial selected item ids (uncontrolled). */
+    defaultValue?: string[];
+    /** Called whenever the selection changes. */
+    onValueChange?: (ids: string[]) => void;
+    /** Called with the ids the user approved (one id per row, many for batch). */
+    onApprove: (ids: string[]) => void;
+    /** Called with the ids the user rejected. */
+    onReject: (ids: string[]) => void;
+    children: React.ReactNode;
+}
+type BatchApprovalHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$7(props: BatchApprovalHeaderProps): React.JSX.Element;
+type BatchApprovalIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$7(props: BatchApprovalIconProps): React.JSX.Element;
+type BatchApprovalTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** What the queue is: "Agent proposed 6 actions". */
+declare function Title$7(props: BatchApprovalTitleProps): React.JSX.Element;
+type BatchApprovalDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function Description$5(props: BatchApprovalDescriptionProps): React.JSX.Element;
+type BatchApprovalToolbarProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * The batch triage bar. Holds `SelectAll`, a live `SelectionCount`, and the
+ * batch `Approve` / `Reject` buttons — all scoped to the selectable items.
+ */
+declare function Toolbar(props: BatchApprovalToolbarProps): React.JSX.Element;
+type BatchApprovalSelectAllProps = Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & {
+    /** Label content; defaults to "Select all reviewable". */
+    children?: React.ReactNode;
+};
+/**
+ * Selects every *selectable* item at once — items marked `requiresReview` are
+ * never included, so "select all" can never sweep up the item that most needs
+ * a person. Reflects the mixed state as `indeterminate`.
+ */
+declare function SelectAll({ children, ...rest }: BatchApprovalSelectAllProps): React.JSX.Element;
+interface BatchApprovalSelectionCountProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+    /**
+     * Render function receiving the live counts, so a label can read
+     * "3 of 5 selected" without lifting state. Defaults to "{n} selected".
+     */
+    children?: (state: {
+        selectedCount: number;
+        selectableCount: number;
+    }) => React.ReactNode;
+}
+/** Live, polite count of what a batch action would touch. */
+declare function SelectionCount({ children, ...rest }: BatchApprovalSelectionCountProps): React.JSX.Element;
+type BatchApprovalButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+type BatchApprovalListProps = React.HTMLAttributes<HTMLUListElement>;
+declare function List$2(props: BatchApprovalListProps): React.JSX.Element;
+interface BatchApprovalItemProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, "id" | "title"> {
+    /** Stable id; must appear in the root's `items`. */
+    id: string;
+    /** The proposed action, as a verb phrase: "Send reply to Dana Okafor". */
+    title: React.ReactNode;
+    /** One line of specifics under the title. */
+    detail?: React.ReactNode;
+}
+/**
+ * One row of the queue. Renders its own selection checkbox — disabled and
+ * replaced with a "review individually" flag when the item `requiresReview`.
+ * Per-row action buttons (`Item.Approve` / `Item.Reject`) go in `children`.
+ */
+declare function Item({ id, title, detail, children, ...rest }: BatchApprovalItemProps): React.JSX.Element;
+declare const BatchApproval: {
+    Root: React.ForwardRefExoticComponent<BatchApprovalRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$7;
+    Icon: typeof Icon$7;
+    Title: typeof Title$7;
+    Description: typeof Description$5;
+    Toolbar: typeof Toolbar;
+    SelectAll: typeof SelectAll;
+    SelectionCount: typeof SelectionCount;
+    BatchApprove: React.ForwardRefExoticComponent<BatchApprovalButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    BatchReject: React.ForwardRefExoticComponent<BatchApprovalButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    List: typeof List$2;
+    Item: typeof Item;
+    ItemApprove: React.ForwardRefExoticComponent<BatchApprovalButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    ItemReject: React.ForwardRefExoticComponent<BatchApprovalButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Consent Memory — the choice of *how long* a permission lasts, made legible.
+ * When an agent asks to do something, "Always allow" is the fastest way out of
+ * the prompt, so users pick it under task focus without registering that they
+ * just signed a standing grant. This pattern turns durability into a first-
+ * class, reviewable decision: every option spells out the future it commits
+ * you to, and the least-standing choice is the resting default.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * The selected option is controllable via `value` / `onValueChange` or
+ * uncontrolled via `defaultValue`. The confirm button reports the chosen
+ * durability so its label and the payload have a single source of truth.
+ */
+/**
+ * How long the grant persists. `once` is the safe default; the others are
+ * standing to increasing degrees — `scoped` binds to a narrow condition,
+ * `always` is an unconditional standing grant.
+ */
+type ConsentDurability = "once" | "session" | "scoped" | "always";
+interface ConsentMemoryRootProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    /** Selected option value (controlled). */
+    value?: string;
+    /** Initial selected option value (uncontrolled). Point it at the `once` option. */
+    defaultValue?: string;
+    /** Called when the selected durability option changes. */
+    onValueChange?: (value: string) => void;
+    /** Called with the chosen option value when the user confirms. */
+    onAllow: (value: string) => void;
+    /** Called when the user declines entirely. */
+    onDeny: () => void;
+    children: React.ReactNode;
+}
+type ConsentMemoryHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$6(props: ConsentMemoryHeaderProps): React.JSX.Element;
+type ConsentMemoryIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$6(props: ConsentMemoryIconProps): React.JSX.Element;
+type ConsentMemoryTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The permission being asked about: "Allow Inbox Assistant to send email?". */
+declare function Title$6(props: ConsentMemoryTitleProps): React.JSX.Element;
+type ConsentMemoryDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+/** The concrete action prompting the request, above the durability choice. */
+declare function Description$4(props: ConsentMemoryDescriptionProps): React.JSX.Element;
+type ConsentMemoryOptionsProps = React.FieldsetHTMLAttributes<HTMLFieldSetElement> & {
+    /** Legend for the durability choice; defaults to "Apply this decision:". */
+    legend?: React.ReactNode;
+};
+/**
+ * The set of durability choices, as a radio group. Renders a fieldset/legend
+ * so assistive tech announces "how long should this apply" as one grouping.
+ */
+declare function Options({ legend, children, ...rest }: ConsentMemoryOptionsProps): React.JSX.Element;
+interface ConsentMemoryOptionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Stable value passed to `onAllow` when this option is selected. */
+    value: string;
+    /** How standing this grant is — drives styling and the confirm label. */
+    durability: ConsentDurability;
+    /** The choice itself: "Always, for this recipient". */
+    label: React.ReactNode;
+    /**
+     * The future this choice commits to, in plain language: "The agent can email
+     * Dana any time without asking again." This is the point of the pattern.
+     */
+    consequence: React.ReactNode;
+}
+/**
+ * One durability choice. The radio and its consequence are bound together so
+ * the standing implication is never more than a line from the choice itself.
+ */
+declare function Option({ value, durability, label, consequence, ...rest }: ConsentMemoryOptionProps): React.JSX.Element;
+type ConsentMemoryActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$4(props: ConsentMemoryActionsProps): React.JSX.Element;
+interface ConsentMemoryAllowProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    /**
+     * Button content. As a render function it receives the selected durability,
+     * so the label can read "Allow always" vs "Allow once" without lifting state.
+     */
+    children: React.ReactNode | ((state: {
+        durability: ConsentDurability | null;
+    }) => React.ReactNode);
+}
+type ConsentMemoryDenyProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const ConsentMemory: {
+    Root: React.ForwardRefExoticComponent<ConsentMemoryRootProps & React.RefAttributes<HTMLFormElement>>;
+    Header: typeof Header$6;
+    Icon: typeof Icon$6;
+    Title: typeof Title$6;
+    Description: typeof Description$4;
+    Options: typeof Options;
+    Option: typeof Option;
+    Actions: typeof Actions$4;
+    Allow: React.ForwardRefExoticComponent<ConsentMemoryAllowProps & React.RefAttributes<HTMLButtonElement>>;
+    Deny: React.ForwardRefExoticComponent<ConsentMemoryDenyProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * How much standing authority a capability carries.
+ * - `auto`: the agent may do it unattended.
+ * - `ask`: the agent must ask for confirmation each time (the safe default).
+ * - `never`: the agent may not do it at all.
+ */
+type AuthorityLevel = "auto" | "ask" | "never";
+declare const AUTHORITY_LEVELS: AuthorityLevel[];
+interface AuthorityBoundaryRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect" | "defaultValue"> {
+    /** Capability id → authority level (controlled). */
+    value?: Record<string, AuthorityLevel>;
+    /** Initial capability id → authority level (uncontrolled). */
+    defaultValue?: Record<string, AuthorityLevel>;
+    /** Called with the full level map whenever any capability changes. */
+    onValueChange?: (value: Record<string, AuthorityLevel>) => void;
+    children: React.ReactNode;
+}
+type AuthorityBoundaryHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$5(props: AuthorityBoundaryHeaderProps): React.JSX.Element;
+type AuthorityBoundaryIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$5(props: AuthorityBoundaryIconProps): React.JSX.Element;
+type AuthorityBoundaryTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The question the surface answers: "What can Inbox Assistant do on its own?". */
+declare function Title$5(props: AuthorityBoundaryTitleProps): React.JSX.Element;
+type AuthorityBoundaryDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function Description$3(props: AuthorityBoundaryDescriptionProps): React.JSX.Element;
+interface AuthorityBoundarySummaryProps extends Omit<React.HTMLAttributes<HTMLParagraphElement>, "children"> {
+    /**
+     * Render function receiving the live per-level counts, so the surface can
+     * state "3 automatic · 2 ask first · 1 never" at a glance.
+     */
+    children: (counts: Record<AuthorityLevel, number>) => React.ReactNode;
+}
+/** A live, at-a-glance tally of how much standing authority is granted. */
+declare function Summary$1({ children, ...rest }: AuthorityBoundarySummaryProps): React.JSX.Element;
+type AuthorityBoundaryListProps = React.HTMLAttributes<HTMLUListElement>;
+declare function List$1(props: AuthorityBoundaryListProps): React.JSX.Element;
+interface AuthorityBoundaryCapabilityProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, "id"> {
+    /** Stable id used as the key in the level map. */
+    id: string;
+    /** Power level of this capability — a text badge, never color alone. */
+    access: ScopeAccess;
+    /** Plain-language capability name: "Send email on your behalf". */
+    label: React.ReactNode;
+    /** What the agent does with this capability. */
+    description?: React.ReactNode;
+    /**
+     * Levels this capability may not be set to. Use it to forbid `auto` on an
+     * irreversible capability, so the UI can't grant standing authority to
+     * something that should always be confirmed.
+     */
+    disallow?: AuthorityLevel[];
+}
+/**
+ * One capability row with its segmented authority control. The control is a
+ * real radio group (a fieldset with a screen-reader legend naming the
+ * capability), so each capability's authority is an independent, labelled
+ * choice.
+ */
+declare function Capability({ id, access, label, description, disallow, ...rest }: AuthorityBoundaryCapabilityProps): React.JSX.Element;
+declare const AuthorityBoundary: {
+    Root: React.ForwardRefExoticComponent<AuthorityBoundaryRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$5;
+    Icon: typeof Icon$5;
+    Title: typeof Title$5;
+    Description: typeof Description$3;
+    Summary: typeof Summary$1;
+    List: typeof List$1;
+    Capability: typeof Capability;
+};
+
+/**
+ * Spend & Rate Limits — numeric guardrails treated as consent primitives, not
+ * billing settings. A budget cap, an action count, a time window: each is a
+ * standing decision about how far an agent may go before it has to come back
+ * and ask. This pattern gives those numbers one surface, shows each cap against
+ * live usage so the boundary is legible, and makes clear that reaching a cap is
+ * a *consent* event — the agent pauses and asks rather than silently stopping.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * Usage facts (`limits`) are declared once at the Root — the single source of
+ * truth for consumption and the summary tally. The caps are controllable via
+ * `value` / `onValueChange` or uncontrolled via `defaultValue` (a record of
+ * limit id → cap). A limit with no cap entry is treated as having no limit set.
+ */
+/** Whether a limit meters money (`spend`) or a count of actions (`rate`). */
+type SpendLimitKind = "spend" | "rate";
+/** The window a cap resets over. */
+type SpendLimitPeriod = "day" | "week" | "month";
+/**
+ * How a limit stands against its cap.
+ * - `none`: no cap set — the agent is unbounded on this axis.
+ * - `ok`: comfortably under the cap.
+ * - `warning`: at or past 80% of the cap.
+ * - `reached`: at or over the cap; the agent must ask before doing more.
+ */
+type SpendLimitState = "none" | "ok" | "warning" | "reached";
+/** A consumption fact: how much of a limit has been used so far this window. */
+interface SpendLimitUsage {
+    /** Stable id, keyed to a `Limit` child and to the cap map. */
+    id: string;
+    /** Amount consumed this window — dollars for `spend`, a count for `rate`. */
+    used: number;
+}
+interface SpendLimitsSummary {
+    total: number;
+    ok: number;
+    warning: number;
+    reached: number;
+}
+interface SpendLimitsRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect" | "defaultValue"> {
+    /**
+     * Consumption facts, one per limit — the single source of truth for usage and
+     * the summary tally. Declare every limit you render a `Limit` for.
+     */
+    limits: SpendLimitUsage[];
+    /** Limit id → cap (controlled). */
+    value?: Record<string, number>;
+    /** Initial limit id → cap (uncontrolled). */
+    defaultValue?: Record<string, number>;
+    /** Called with the full cap map whenever any cap changes. */
+    onValueChange?: (value: Record<string, number>) => void;
+    children: React.ReactNode;
+}
+type SpendLimitsHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$4(props: SpendLimitsHeaderProps): React.JSX.Element;
+type SpendLimitsIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$4(props: SpendLimitsIconProps): React.JSX.Element;
+type SpendLimitsTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The question the surface answers: "How far can Shopping Agent go alone?". */
+declare function Title$4(props: SpendLimitsTitleProps): React.JSX.Element;
+type SpendLimitsDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function Description$2(props: SpendLimitsDescriptionProps): React.JSX.Element;
+interface SpendLimitsSummaryProps extends Omit<React.HTMLAttributes<HTMLParagraphElement>, "children"> {
+    /**
+     * Render function receiving the live per-state counts, so the surface can
+     * state "1 cap reached · 1 near cap" at a glance.
+     */
+    children: (summary: SpendLimitsSummary) => React.ReactNode;
+}
+/** A live, at-a-glance read of how close the agent is to its guardrails. */
+declare function Summary({ children, ...rest }: SpendLimitsSummaryProps): React.JSX.Element;
+type SpendLimitsListProps = React.HTMLAttributes<HTMLUListElement>;
+declare function List(props: SpendLimitsListProps): React.JSX.Element;
+interface SpendLimitsLimitProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, "id"> {
+    /** Stable id used to look up usage and the cap. */
+    id: string;
+    /** Whether this limit meters money or a count of actions. */
+    kind: SpendLimitKind;
+    /**
+     * The unit. For `spend`, a currency symbol shown before the amount ("$").
+     * For `rate`, the noun shown after it ("emails", "API calls").
+     */
+    unit: string;
+    /** The window this cap resets over. */
+    period: SpendLimitPeriod;
+    /** Plain-language name for the guardrail: "Purchases". */
+    label: React.ReactNode;
+    /** What the agent spends this budget on. */
+    description?: React.ReactNode;
+}
+/**
+ * One guardrail row: a labelled cap, a meter of usage against it, and an
+ * editable number so the user can tighten or loosen the boundary in place. The
+ * cap is a real number input, labelled per limit, so the guardrail is a single,
+ * legible, keyboard-accessible control.
+ */
+declare function Limit({ id, kind, unit, period, label, description, ...rest }: SpendLimitsLimitProps): React.JSX.Element;
+declare const SpendLimits: {
+    Root: React.ForwardRefExoticComponent<SpendLimitsRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$4;
+    Icon: typeof Icon$4;
+    Title: typeof Title$4;
+    Description: typeof Description$2;
+    Summary: typeof Summary;
+    List: typeof List;
+    Limit: typeof Limit;
+};
+
+/**
+ * Credential Handoff — an agent should never see a password or a card number.
+ * When a task needs a secret, the agent steps aside and hands the exchange to a
+ * trusted holder — a password manager, a passkey, the provider's own payment
+ * page — which returns a scoped credential (a signed-in session, a one-time
+ * token) rather than the secret itself. This surface makes that boundary
+ * legible: it names who will hold the secret, states plainly that the agent is
+ * excluded, and shows what comes back instead.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * A decision surface: `onHandoff` continues into the trusted holder,
+ * `onCancel` backs out. It is deliberately not a form — it never collects the
+ * secret itself.
+ */
+/** What kind of trusted holder the secret is handed to. */
+type HandoffHandlerKind = "password-manager" | "passkey" | "payment" | "provider";
+interface CredentialHandoffRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+    /** Called when the user continues into the trusted holder. */
+    onHandoff: () => void;
+    /** Called when the user backs out without handing off. */
+    onCancel: () => void;
+    children: React.ReactNode;
+}
+type CredentialHandoffHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$3(props: CredentialHandoffHeaderProps): React.JSX.Element;
+type CredentialHandoffIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$3(props: CredentialHandoffIconProps): React.JSX.Element;
+type CredentialHandoffTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The task needing a secret: "Sign in to Delta" or "Pay Delta $340.00". */
+declare function Title$3(props: CredentialHandoffTitleProps): React.JSX.Element;
+type CredentialHandoffDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function Description$1(props: CredentialHandoffDescriptionProps): React.JSX.Element;
+interface CredentialHandoffHandlerProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** What kind of holder this is — surfaced as a text badge. */
+    kind: HandoffHandlerKind;
+    /** The holder's name: "1Password", "Apple Pay", "Delta's payment page". */
+    name: React.ReactNode;
+}
+/**
+ * The trusted holder the secret goes to. Naming it — and its kind — is how the
+ * user knows the exchange leaves the agent for something they already trust.
+ */
+declare function Handler({ kind, name, children, ...rest }: CredentialHandoffHandlerProps): React.JSX.Element;
+type CredentialHandoffBoundaryProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * The pattern's distinct element: an explicit statement that the agent is
+ * outside this exchange. Rendered as a `note` so assistive tech announces the
+ * exclusion, not just the visual fence.
+ */
+declare function Boundary(props: CredentialHandoffBoundaryProps): React.JSX.Element;
+type CredentialHandoffReturnsProps = React.HTMLAttributes<HTMLUListElement> & {
+    /** Heading for the list; defaults to "The agent receives:". */
+    legend?: React.ReactNode;
+};
+/**
+ * What the agent gets back in place of the secret — a scoped session, a
+ * one-time token, a confirmation. Never the secret itself.
+ */
+declare function Returns({ legend, children, ...rest }: CredentialHandoffReturnsProps): React.JSX.Element;
+type CredentialHandoffReturnProps = React.LiHTMLAttributes<HTMLLIElement>;
+declare function Return(props: CredentialHandoffReturnProps): React.JSX.Element;
+type CredentialHandoffActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$3(props: CredentialHandoffActionsProps): React.JSX.Element;
+type CredentialHandoffButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const CredentialHandoff: {
+    Root: React.ForwardRefExoticComponent<CredentialHandoffRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$3;
+    Icon: typeof Icon$3;
+    Title: typeof Title$3;
+    Description: typeof Description$1;
+    Handler: typeof Handler;
+    Boundary: typeof Boundary;
+    Returns: typeof Returns;
+    Return: typeof Return;
+    Actions: typeof Actions$3;
+    Handoff: React.ForwardRefExoticComponent<CredentialHandoffButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    Cancel: React.ForwardRefExoticComponent<CredentialHandoffButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Action Receipt — consent doesn't end at approval. After an agent acts, the
+ * user needs a durable record of what it did, under what authority, and when —
+ * with a way to undo it where the action allows. Without a receipt, an approval
+ * (or a standing grant firing on its own) vanishes the moment it executes, and
+ * the user has no surface to notice, question, or reverse it.
+ *
+ * Headless compound component. All parts render unstyled with `data-acp`
+ * attributes as styling hooks; import `@agentconsent/react/theme.css`
+ * for the default theme.
+ *
+ * Like Connection Card, this is a display surface: it takes no decision
+ * callbacks of its own. The one interactive part, `Undo`, is wired to your
+ * handler — and it renders as an inert note (not a button) when the action was
+ * irreversible or has already been undone, so the receipt can never offer an
+ * undo it can't honour.
+ */
+/** How the action turned out. Drives the outcome badge and styling. */
+type ReceiptOutcome = "completed" | "undone" | "failed";
+/** Whether the action can be reversed — governs whether Undo is offered. */
+type ReceiptReversibility = "reversible" | "irreversible";
+interface ActionReceiptRootProps extends React.HTMLAttributes<HTMLElement> {
+    /** How the action turned out. Defaults to `completed`. */
+    outcome?: ReceiptOutcome;
+    /**
+     * Whether the action can be reversed. Defaults to `reversible`. An
+     * `irreversible` receipt renders no undo button — only an honest note.
+     */
+    reversibility?: ReceiptReversibility;
+    children: React.ReactNode;
+}
+type ActionReceiptHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$2(props: ActionReceiptHeaderProps): React.JSX.Element;
+type ActionReceiptIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$2(props: ActionReceiptIconProps): React.JSX.Element;
+type ActionReceiptTitleProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * What the agent did, in the past tense: "Sent email to Dana Ito". A non-heading
+ * element with an id, so a receipt slots into an activity log at any depth
+ * without imposing a heading level.
+ */
+declare function Title$2(props: ActionReceiptTitleProps): React.JSX.Element;
+type ActionReceiptOutcomeProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * The outcome badge, as text (never color alone). Pass children to override the
+ * wording.
+ */
+declare function Outcome({ children, ...rest }: ActionReceiptOutcomeProps): React.JSX.Element;
+type ActionReceiptDetailsProps = React.HTMLAttributes<HTMLDListElement>;
+declare function Details(props: ActionReceiptDetailsProps): React.JSX.Element;
+interface ActionReceiptDetailProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The fact's name: "To", "Amount", "File". */
+    label: React.ReactNode;
+    /** The exact value acted on — never a summary. */
+    children: React.ReactNode;
+}
+declare function Detail({ label, children, ...rest }: ActionReceiptDetailProps): React.JSX.Element;
+interface ActionReceiptAuthorityProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The grant, approval, or standing rule the action ran under. */
+    grant: React.ReactNode;
+    /** How that authority was established: "you approved · Jul 8", "always-allow". */
+    via?: React.ReactNode;
+}
+/**
+ * Under what authority the action was taken — the receipt's distinct job. It
+ * ties the act back to the consent that permitted it, so a user reviewing the
+ * log can see *why* the agent was allowed to do this, not just that it did.
+ */
+declare function Authority({ grant, via, children, ...rest }: ActionReceiptAuthorityProps): React.JSX.Element;
+type ActionReceiptMetaProps = React.HTMLAttributes<HTMLDListElement>;
+declare function Meta$1(props: ActionReceiptMetaProps): React.JSX.Element;
+interface ActionReceiptMetaItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The fact's name: "When", "Reference". */
+    label: React.ReactNode;
+    children: React.ReactNode;
+}
+declare function MetaItem$1({ label, children, ...rest }: ActionReceiptMetaItemProps): React.JSX.Element;
+type ActionReceiptActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$2(props: ActionReceiptActionsProps): React.JSX.Element;
+interface ActionReceiptUndoProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Note shown in place of the button when the action can't be undone.
+     * Defaults to "Can't be undone".
+     */
+    irreversibleNote?: React.ReactNode;
+    /** Note shown once the action has already been undone. Defaults to "Undone". */
+    undoneNote?: React.ReactNode;
+}
+declare const ActionReceipt: {
+    Root: React.ForwardRefExoticComponent<ActionReceiptRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$2;
+    Icon: typeof Icon$2;
+    Title: typeof Title$2;
+    Outcome: typeof Outcome;
+    Details: typeof Details;
+    Detail: typeof Detail;
+    Authority: typeof Authority;
+    Meta: typeof Meta$1;
+    MetaItem: typeof MetaItem$1;
+    Actions: typeof Actions$2;
+    Undo: React.ForwardRefExoticComponent<ActionReceiptUndoProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+interface InjectionFlagRootProps extends Omit<React.HTMLAttributes<HTMLElement>, "onSelect"> {
+    /** Called when the user chooses to follow the flagged instruction. */
+    onProceed: () => void;
+    /**
+     * Called when the user declines to follow it (button, or Escape in modal
+     * mode). This is the safe path — the agent keeps doing what the *user* asked.
+     */
+    onDismiss: () => void;
+    /** Render as a modal AlertDialog instead of an inline card. */
+    asModal?: boolean;
+    /** Modal mode only: whether the dialog is open (controlled). */
+    open?: boolean;
+    /** Modal mode only: called when the dialog requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+type InjectionFlagHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header$1(props: InjectionFlagHeaderProps): React.JSX.Element;
+type InjectionFlagIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon$1(props: InjectionFlagIconProps): React.JSX.Element;
+type InjectionFlagTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+/** The situation, stated plainly: "An instruction came from untrusted content". */
+declare function Title$1(props: InjectionFlagTitleProps): React.JSX.Element;
+type InjectionFlagDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+/** Plain-language framing of why this is being surfaced. */
+declare function Description(props: InjectionFlagDescriptionProps): React.JSX.Element;
+interface InjectionFlagSourceProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The untrusted origin type: "a web page", "an email", "an uploaded file". */
+    origin: React.ReactNode;
+    /** A specific pointer to it: a URL, a sender, a filename. */
+    location?: React.ReactNode;
+}
+/**
+ * Where the instruction came from — the provenance that makes it untrusted.
+ * Carried in text (and an untrusted accent), never implied by styling alone.
+ */
+declare function Source({ origin, location, children, ...rest }: InjectionFlagSourceProps): React.JSX.Element;
+interface InjectionFlagQuoteProps extends React.HTMLAttributes<HTMLQuoteElement> {
+    /** Label above the quote; defaults to "The instruction reads:". */
+    label?: React.ReactNode;
+    /** The flagged instruction, quoted exactly as it appeared. */
+    children: React.ReactNode;
+}
+/**
+ * The injected instruction, quoted verbatim and visually fenced. Showing the
+ * literal text — not a paraphrase — is the heart of the pattern: the user sees
+ * exactly what is trying to steer the agent.
+ */
+declare function Quote({ label, children, ...rest }: InjectionFlagQuoteProps): React.JSX.Element;
+type InjectionFlagConsequenceProps = React.HTMLAttributes<HTMLParagraphElement>;
+/**
+ * What the agent would do if it followed the instruction, stated concretely so
+ * the stakes of "Proceed" are legible: "I would forward your inbox to an
+ * outside address."
+ */
+declare function Consequence(props: InjectionFlagConsequenceProps): React.JSX.Element;
+type InjectionFlagActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions$1(props: InjectionFlagActionsProps): React.JSX.Element;
+type InjectionFlagButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+declare const InjectionFlag: {
+    Root: React.ForwardRefExoticComponent<InjectionFlagRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header$1;
+    Icon: typeof Icon$1;
+    Title: typeof Title$1;
+    Description: typeof Description;
+    Source: typeof Source;
+    Quote: typeof Quote;
+    Consequence: typeof Consequence;
+    Actions: typeof Actions$1;
+    Proceed: React.ForwardRefExoticComponent<InjectionFlagButtonProps & React.RefAttributes<HTMLButtonElement>>;
+    Dismiss: React.ForwardRefExoticComponent<InjectionFlagButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+type ConnectionStatus = "active" | "paused" | "needs-reauth" | "expired";
+interface ConnectionCardRootProps extends React.HTMLAttributes<HTMLElement> {
+    /** Lifecycle state of the connection — drives the status badge + styling. */
+    status?: ConnectionStatus;
+    children: React.ReactNode;
+}
+type ConnectionCardHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Header(props: ConnectionCardHeaderProps): React.JSX.Element;
+type ConnectionCardIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function Icon(props: ConnectionCardIconProps): React.JSX.Element;
+type ConnectionCardTitleProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * Who is connected to what: "Inbox Assistant → Gmail". Rendered as a
+ * non-heading element with an id so the card's accessible name works at any
+ * position in a settings list without imposing a heading level.
+ */
+declare function Title(props: ConnectionCardTitleProps): React.JSX.Element;
+type ConnectionCardStatusProps = React.HTMLAttributes<HTMLSpanElement>;
+/**
+ * The lifecycle badge. Defaults to the status label as text (never color
+ * alone); pass children to override the wording.
+ */
+declare function Status({ children, ...rest }: ConnectionCardStatusProps): React.JSX.Element;
+type ConnectionCardScopesProps = React.HTMLAttributes<HTMLUListElement>;
+declare function Scopes(props: ConnectionCardScopesProps): React.JSX.Element;
+interface ConnectionCardScopeProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    /** Access level of this active capability — surfaced as a text badge. */
+    access: ScopeAccess;
+    /** Plain-language capability name: "Send messages". */
+    children: React.ReactNode;
+}
+declare function Scope({ access, children, ...rest }: ConnectionCardScopeProps): React.JSX.Element;
+type ConnectionCardMetaProps = React.HTMLAttributes<HTMLDListElement>;
+declare function Meta(props: ConnectionCardMetaProps): React.JSX.Element;
+interface ConnectionCardMetaItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The fact's name: "Last used", "Connected". */
+    label: React.ReactNode;
+    children: React.ReactNode;
+}
+declare function MetaItem({ label, children, ...rest }: ConnectionCardMetaItemProps): React.JSX.Element;
+type ConnectionCardActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function Actions(props: ConnectionCardActionsProps): React.JSX.Element;
+interface ConnectionCardActionProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** "danger" styles a destructive management action such as revoke. */
+    tone?: "default" | "danger";
+}
+declare const ConnectionCard: {
+    Root: React.ForwardRefExoticComponent<ConnectionCardRootProps & React.RefAttributes<HTMLElement>>;
+    Header: typeof Header;
+    Icon: typeof Icon;
+    Title: typeof Title;
+    Status: typeof Status;
+    Scopes: typeof Scopes;
+    Scope: typeof Scope;
+    Meta: typeof Meta;
+    MetaItem: typeof MetaItem;
+    Actions: typeof Actions;
+    Action: React.ForwardRefExoticComponent<ConnectionCardActionProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+export { AUTHORITY_LEVELS, ActionPreview, type ActionPreviewActionsProps, type ActionPreviewButtonProps, type ActionPreviewConsequence, type ActionPreviewContentProps, type ActionPreviewFieldProps, type ActionPreviewFieldsProps, type ActionPreviewHeaderProps, type ActionPreviewIconProps, type ActionPreviewRootProps, type ActionPreviewSourceProps, type ActionPreviewTitleProps, ActionReceipt, type ActionReceiptActionsProps, type ActionReceiptAuthorityProps, type ActionReceiptDetailProps, type ActionReceiptDetailsProps, type ActionReceiptHeaderProps, type ActionReceiptIconProps, type ActionReceiptMetaItemProps, type ActionReceiptMetaProps, type ActionReceiptOutcomeProps, type ActionReceiptRootProps, type ActionReceiptTitleProps, type ActionReceiptUndoProps, AuthorityBoundary, type AuthorityBoundaryCapabilityProps, type AuthorityBoundaryDescriptionProps, type AuthorityBoundaryHeaderProps, type AuthorityBoundaryIconProps, type AuthorityBoundaryListProps, type AuthorityBoundaryRootProps, type AuthorityBoundarySummaryProps, type AuthorityBoundaryTitleProps, type AuthorityLevel, BatchApproval, type BatchApprovalButtonProps, type BatchApprovalDescriptionProps, type BatchApprovalHeaderProps, type BatchApprovalIconProps, type BatchApprovalItem, type BatchApprovalItemProps, type BatchApprovalListProps, type BatchApprovalRootProps, type BatchApprovalSelectAllProps, type BatchApprovalSelectionCountProps, type BatchApprovalTitleProps, type BatchApprovalToolbarProps, ConnectionCard, type ConnectionCardActionProps, type ConnectionCardActionsProps, type ConnectionCardHeaderProps, type ConnectionCardIconProps, type ConnectionCardMetaItemProps, type ConnectionCardMetaProps, type ConnectionCardRootProps, type ConnectionCardScopeProps, type ConnectionCardScopesProps, type ConnectionCardStatusProps, type ConnectionCardTitleProps, type ConnectionStatus, type ConsentDurability, ConsentMemory, type ConsentMemoryActionsProps, type ConsentMemoryAllowProps, type ConsentMemoryDenyProps, type ConsentMemoryDescriptionProps, type ConsentMemoryHeaderProps, type ConsentMemoryIconProps, type ConsentMemoryOptionProps, type ConsentMemoryOptionsProps, type ConsentMemoryRootProps, type ConsentMemoryTitleProps, CredentialHandoff, type CredentialHandoffActionsProps, type CredentialHandoffBoundaryProps, type CredentialHandoffButtonProps, type CredentialHandoffDescriptionProps, type CredentialHandoffHandlerProps, type CredentialHandoffHeaderProps, type CredentialHandoffIconProps, type CredentialHandoffReturnProps, type CredentialHandoffReturnsProps, type CredentialHandoffRootProps, type CredentialHandoffTitleProps, type HandoffHandlerKind, InjectionFlag, type InjectionFlagActionsProps, type InjectionFlagButtonProps, type InjectionFlagConsequenceProps, type InjectionFlagDescriptionProps, type InjectionFlagHeaderProps, type InjectionFlagIconProps, type InjectionFlagQuoteProps, type InjectionFlagRootProps, type InjectionFlagSourceProps, type InjectionFlagTitleProps, IrreversibilityGate, type IrreversibilityGateActionsProps, type IrreversibilityGateButtonProps, type IrreversibilityGateConfirmFieldProps, type IrreversibilityGateConsequenceProps, type IrreversibilityGateConsequencesProps, type IrreversibilityGateDescriptionProps, type IrreversibilityGateHeaderProps, type IrreversibilityGateIconProps, type IrreversibilityGateRootProps, type IrreversibilityGateTitleProps, type IrreversibilitySeverity, ProgressiveScope, type ProgressiveScopeActionsProps, type ProgressiveScopeButtonProps, type ProgressiveScopeCurrentProps, type ProgressiveScopeHeaderProps, type ProgressiveScopeIconProps, type ProgressiveScopeReasonProps, type ProgressiveScopeRequestProps, type ProgressiveScopeRootProps, type ProgressiveScopeTitleProps, type ReceiptOutcome, type ReceiptReversibility, type ScopeAccess, ScopedGrant, type ScopedGrantActionsProps, type ScopedGrantCancelProps, type ScopedGrantDescriptionProps, type ScopedGrantGrantProps, type ScopedGrantGroupProps, type ScopedGrantHeaderProps, type ScopedGrantIconProps, type ScopedGrantRootProps, type ScopedGrantScopeProps, type ScopedGrantTitleProps, type SpendLimitKind, type SpendLimitPeriod, type SpendLimitState, type SpendLimitUsage, SpendLimits, type SpendLimitsDescriptionProps, type SpendLimitsHeaderProps, type SpendLimitsIconProps, type SpendLimitsLimitProps, type SpendLimitsListProps, type SpendLimitsRootProps, type SpendLimitsSummaryProps, type SpendLimitsTitleProps };