@opengeni/react 3.3.2 → 3.4.1-canary.38960406141001

package/dist/components/session-usage-limit-notice.d.ts

@@ -0,0 +1,39 @@
+import type { ParsedSessionUsageLimitReachedRefusal, SessionUsageLimit } from "@opengeni/sdk/session-usage-limits";
+import { type SessionUsageLimitLabels } from "../usage/session-usage-limit.js";
+export type SessionUsageLimitNoticeProps = {
+    /** The task's usage-limit projection (`GET .../usage-limit` or `session.usageLimit`). */
+    usage: SessionUsageLimit | null | undefined;
+    /**
+     * A refused Send's typed refusal (`OpenGeniSessionUsageLimitReachedError`),
+     * shown as reached until a re-read projection replaces it. Clear it when a
+     * newer `usage` arrives: a projection that already says reached wins.
+     */
+    refusal?: Pick<ParsedSessionUsageLimitReachedRefusal, "limitMicros" | "usedMicros" | "rootSessionId"> | null;
+    /** Opens the limit editor. Absent: the notice says who can change it instead. */
+    onChangeLimit?: (() => void) | undefined;
+    /** A child chat: link to the main task that owns the limit, instead of an editor. */
+    mainTaskHref?: string | undefined;
+    /** The goal paused at the limit: changing it never resumes, so say Resume is next. */
+    goalPaused?: boolean;
+    /**
+     * The last refresh of `usage` failed. The last known amount and any reached
+     * state stay, with a note that they may be out of date and that the limit
+     * still applies. Pass the read hook's error state; never zero the amount.
+     */
+    stale?: boolean;
+    /**
+     * Remember a dismissed near-limit notice for this tab. The key should name
+     * the workspace; the task and limit version are added, so a changed limit
+     * shows it again. Reaching the limit is never dismissible.
+     */
+    dismissStorageKey?: string | undefined;
+    labels?: Partial<SessionUsageLimitLabels> | undefined;
+    className?: string | undefined;
+};
+/**
+ * The calm composer line for a task's usage limit: a dismissible note near
+ * the limit and a status once it is reached, with one action (Change limit).
+ * Renders nothing while usage is comfortable, unlimited, unknown or loading.
+ * Never a purchase or credits remedy: the limit is a person's own setting.
+ */
+export declare function SessionUsageLimitNotice({ usage, refusal, onChangeLimit, mainTaskHref, goalPaused, stale, dismissStorageKey, labels: overrides, className, }: SessionUsageLimitNoticeProps): import("react").JSX.Element | null;

package/dist/components/timeline-anchor.d.ts

@@ -0,0 +1,24 @@
+import { Component, type ReactNode } from "react";
+type Anchor = {
+    element: HTMLElement;
+    key: string | null;
+    text: string | null;
+    top: number;
+    focused?: boolean;
+};
+export type TimelineAnchor = Anchor[];
+/** Read ownership synchronously: selectionchange may follow the next React commit. */
+export declare function timelineHasReader(scroller: HTMLElement | null): boolean;
+/** Read the old DOM immediately before React changes it, not when a fetch starts. */
+export declare class TimelineBeforeLayout extends Component<{
+    capture: () => void;
+    children: ReactNode;
+}> {
+    getSnapshotBeforeUpdate(): null;
+    componentDidUpdate(): void;
+    render(): ReactNode;
+}
+export declare function captureTimelineAnchor(scroller: HTMLElement): TimelineAnchor | null;
+/** Return only the correction native browser anchoring has not already made. */
+export declare function timelineAnchorCorrection(scroller: HTMLElement, anchors: TimelineAnchor): number | null;
+export {};

package/dist/components/timeline-annotation-chrome.d.ts

@@ -0,0 +1,25 @@
+import type { DraftTimelineAnnotation, TimelineAnnotation, TimelineAnnotationSource } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+export type TimelineAnnotationLike = DraftTimelineAnnotation | TimelineAnnotation;
+export declare function AnnotationQuoteSourceButton({ annotation, lines, onRevealSource, onUnavailable, }: {
+    annotation: TimelineAnnotationLike;
+    lines?: 2 | 3;
+    onRevealSource?: ((source: TimelineAnnotationSource) => boolean) | undefined;
+    onUnavailable: (id: string | null) => void;
+}): import("react").JSX.Element;
+export declare function AnnotationAccentRow({ children, className, }: {
+    children: ReactNode;
+    className?: string | undefined;
+}): import("react").JSX.Element;
+export declare function AnnotationNotePreview({ note, annotationId, ordinal, className, }: {
+    note: string;
+    annotationId: string;
+    ordinal: number;
+    className?: string | undefined;
+}): import("react").JSX.Element | null;
+export declare function AnnotationNoteField({ annotation, inputRef, onUpdate, onCommit, }: {
+    annotation: TimelineAnnotationLike;
+    inputRef?: ((node: HTMLTextAreaElement | null) => void) | undefined;
+    onUpdate: (id: string, note: string) => void;
+    onCommit?: (() => void) | undefined;
+}): import("react").JSX.Element;

package/dist/components/timeline-annotation-layout.d.ts

@@ -0,0 +1,42 @@
+export type AnnotationBox = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export type AnnotationBadgeAnchor = {
+    id: string;
+    ordinal: number;
+    left: number;
+    top: number;
+    incomplete: boolean;
+};
+export declare const ANNOTATION_BADGE_GAP_PX = 32;
+export declare const ANNOTATION_BADGE_MIN_GAP_PX = 12;
+export declare const ANNOTATION_REVIEW_DIALOG_WIDTH_PX = 400;
+export declare const ANNOTATION_REVIEW_DIALOG_MAX_HEIGHT_PX: number;
+export declare const ANNOTATION_REVIEW_DIALOG_MIN_HEIGHT_PX = 160;
+export declare const ANNOTATION_REVIEW_DIALOG_FLOOR_HEIGHT_PX = 80;
+export declare const ANNOTATION_REVIEW_MARGIN_PX = 12;
+export declare const ANNOTATION_NOTE_PREVIEW_CHARS = 280;
+export declare const ANNOTATION_CARD_STACK_SCROLL_AT = 4;
+export declare function annotationBoxIntersects(a: AnnotationBox, b: AnnotationBox): boolean;
+export declare function annotationViewportBox(viewportWidth: number, viewportHeight: number, scroller?: AnnotationBox | null): AnnotationBox;
+export declare function annotationNoteNeedsDisclosure(note: string): boolean;
+export declare function annotationBadgePackGap(viewport: AnnotationBox, count: number, preferred?: number): number;
+export declare function layoutAnnotationBadges(anchors: readonly AnnotationBadgeAnchor[], viewport: AnnotationBox, preferredGap?: number): AnnotationBadgeAnchor[];
+export declare function scrollAnnotationRowIntoList(list: HTMLElement | null | undefined, row: HTMLElement | null | undefined): void;
+export declare function clampAnnotationDialogPlacement(input: {
+    triggerLeft: number;
+    triggerTop: number;
+    triggerBottom: number;
+    contentHeight: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    panelWidth?: number;
+}): {
+    left: number;
+    top: number;
+    maxHeight: number;
+    above: boolean;
+};

package/dist/components/timeline-annotation-markers.d.ts

@@ -0,0 +1,8 @@
+import type { DraftTimelineAnnotation } from "@opengeni/sdk";
+import { type RefObject } from "react";
+export declare function TimelineAnnotationMarkers({ annotations, onSelect, rootRef, }: {
+    annotations: readonly DraftTimelineAnnotation[];
+    onSelect?: ((id: string) => void) | undefined;
+    rootRef: RefObject<HTMLElement | null>;
+}): import("react").ReactPortal | null;
+export default TimelineAnnotationMarkers;

package/dist/components/timeline-annotation-reveal-context.d.ts

@@ -0,0 +1,4 @@
+import { type RefObject } from "react";
+/** Owning timeline scroller for quote-source navigation. */
+export declare const TimelineAnnotationSourceRootContext: import("react").Context<RefObject<HTMLElement | null> | null>;
+export declare function useTimelineAnnotationSourceRoot(): RefObject<HTMLElement | null> | null;

package/dist/components/timeline-annotation-shared.d.ts

@@ -0,0 +1,31 @@
+import type { TimelineAnnotationSource } from "@opengeni/sdk";
+export declare const ANNOTATION_CHROME_SELECTOR = "[data-og-annotation-chrome], [data-og-annotation-badge], [data-og-annotation-popover]";
+export declare function annotationHasNote(note: string): boolean;
+export declare function annotationDisplayOrdinal(annotation: {
+    readonly id?: string;
+    readonly ordinal?: number | undefined;
+}, index: number): number;
+export declare function sourceKindLabel(kind: TimelineAnnotationSource["kind"]): string;
+export declare function annotationSourceLabel(source: TimelineAnnotationSource): string;
+export declare function truncateAnnotationQuote(quote: string, maxChars?: number): string;
+export declare function cssEscapeAttribute(value: string): string;
+export declare function isAnnotationChromeNode(node: Node | null): boolean;
+export declare function occurrenceOffsets(text: string, quote: string): number[];
+export declare function matchingQuoteInSource(sourceText: string, quote: string): string | null;
+type AnnotatableSpan = {
+    node: Text;
+    start: number;
+    length: number;
+};
+export declare function annotatableText(root: HTMLElement): {
+    text: string;
+    spans: AnnotatableSpan[];
+};
+export declare function rangeFromOffsets(spans: AnnotatableSpan[], startOffset: number, endOffset: number): Range | null;
+export declare function buildQuoteRange(sourceEl: HTMLElement, quote: string, occurrenceIndex?: number): Range | null;
+export declare function quoteOccurrenceIndex(sourceEl: HTMLElement, range: Range, quote: string): number;
+export declare function clipRangeToSource(range: Range, sourceEl: HTMLElement): Range | null;
+export declare function visibleClientRect(range: Range): DOMRect | null;
+export declare function resolveAnnotationRevealRoot(from: Element | null | undefined): HTMLElement | null;
+export declare function revealLoadedAnnotationSource(source: TimelineAnnotationSource, root?: ParentNode | null): boolean;
+export {};

package/dist/components/timeline-annotations-dialog.d.ts

@@ -1,7 +1,7 @@
 import type { TimelineAnnotationSource } from "@opengeni/sdk";
 import { type RefObject } from "react";
-import type { TimelineAnnotationLike } from "./timeline-annotations.js";
-export declare function TimelineAnnotationsDialog({ annotations, editable, focusAnnotationId, onFocusConsumed, onUpdate, onRemove, onRevealSource, triggerRef, countLabel, onDismiss, }: {
+import { type TimelineAnnotationLike } from "./timeline-annotation-chrome.js";
+export declare function TimelineAnnotationsDialog({ annotations, editable, focusAnnotationId, onFocusConsumed, onUpdate, onRemove, onRevealSource, triggerRef, countLabel, onDismiss, onCommit, }: {
     annotations: readonly TimelineAnnotationLike[];
     editable: boolean;
     focusAnnotationId?: string | null | undefined;
@@ -12,5 +12,6 @@ export declare function TimelineAnnotationsDialog({ annotations, editable, focus
     triggerRef: RefObject<HTMLButtonElement | null>;
     countLabel: string;
     onDismiss: (restoreFocus: boolean) => void;
+    onCommit: () => void;
 }): import("react").ReactPortal | null;
 export default TimelineAnnotationsDialog;

package/dist/components/timeline-annotations.d.ts

@@ -1,13 +1,23 @@
-import type { DraftTimelineAnnotation, TimelineAnnotation, TimelineAnnotationSource } from "@opengeni/sdk";
-export type TimelineAnnotationLike = DraftTimelineAnnotation | TimelineAnnotation;
-export declare function TimelineAnnotationsChip({ annotations, editable, focusAnnotationId, onFocusConsumed, onUpdate, onRemove, onRevealSource, className, }: {
+import type { TimelineAnnotationSource } from "@opengeni/sdk";
+import { type TimelineAnnotationLike } from "./timeline-annotation-chrome.js";
+export type { TimelineAnnotationLike } from "./timeline-annotation-chrome.js";
+export declare function TimelineAnnotationCards({ annotations, onRevealSource, className, }: {
+    annotations: readonly TimelineAnnotationLike[];
+    onRevealSource?: ((source: TimelineAnnotationSource) => boolean) | undefined;
+    className?: string | undefined;
+}): import("react").JSX.Element | null;
+export declare function TimelineAnnotationsChip({ annotations, editable, focusAnnotationId, onFocusConsumed, onUpdate, onRemove, onRevealSource, className, compact, onCommit, }: {
     annotations: readonly TimelineAnnotationLike[];
     editable?: boolean | undefined;
     focusAnnotationId?: string | null | undefined;
     onFocusConsumed?: (() => void) | undefined;
     onUpdate?: ((id: string, note: string) => void) | undefined;
     onRemove?: ((id: string) => void) | undefined;
+    /** Return focus to the owning input after all notes are completed with Enter. */
+    onCommit?: (() => void) | undefined;
     onRevealSource?: ((source: TimelineAnnotationSource) => boolean) | undefined;
     className?: string | undefined;
+    /** Dense trigger for single-line rows such as the compact queue dock. */
+    compact?: boolean | undefined;
 }): import("react").JSX.Element | null;
 export default TimelineAnnotationsChip;

package/dist/components/timeline-reading-progress.d.ts

@@ -0,0 +1,11 @@
+import type { TimelineGroup } from "../timeline/types.js";
+/**
+ * Settlement may compact history, but cannot remove prose beneath a reader.
+ * Keep only progress that was already primary on the preceding commit; loading
+ * settled history never expands it. An explicit work toggle or tip return ends
+ * the protection. Keeping the original sibling keys also preserves selection.
+ */
+export declare function useReadingProgress(projected: TimelineGroup[], pinned: boolean, scroller: HTMLElement | null): {
+    groups: TimelineGroup[];
+    release: (id: string | null) => void;
+};

package/dist/components/timeline-search.d.ts

@@ -0,0 +1,34 @@
+import { type RefObject } from "react";
+import type { TimelineItem } from "../timeline/types.js";
+export type TimelineSearchTarget = {
+    sequence: number;
+    eventId?: string | undefined;
+    /** Literal, case-insensitive text. No regex interpretation. */
+    query: string;
+    /** Zero-based occurrence within the source message. Defaults to zero. */
+    occurrence?: number | undefined;
+    /**
+     * Zero-based UTF-16 offset of the match in the original message text, as
+     * reported by backend all-occurrence search (messageMatchOffset). When set
+     * it takes precedence over `occurrence` and is validated against `query`,
+     * so a stale offset degrades to no highlight rather than a wrong one.
+     */
+    offset?: number | undefined;
+};
+/** Scoped to the target's group; disclosure expansion persists after closing find. */
+export declare const TimelineSearchRevealContext: import("react").Context<string | null>;
+export declare const useTimelineSearchReveal: () => string | null;
+export declare function isTimelineSearchTarget(item: TimelineItem, target: TimelineSearchTarget): boolean;
+/** Scan without allocating an offset array proportional to a huge message. */
+export declare function literalSearchOffset(text: string, query: string, occurrence?: number): number;
+/**
+ * Validate a caller-supplied UTF-16 offset against the text and query. The
+ * sticky flag pins the match to exactly `offset`; like literalSearchOffset,
+ * regex escaping keeps offsets in UTF-16 units even for length-changing case
+ * folds. Returns -1 when the offset is stale or the text no longer matches.
+ */
+export declare function matchAtOffset(text: string, query: string, offset: number): number;
+/** Resolve a target to a UTF-16 offset: explicit offset wins, else the ordinal scan. */
+export declare function searchMatchOffset(text: string, target: TimelineSearchTarget): number;
+/** Range highlighting does not mutate React-owned text or its layout. */
+export declare function useTimelineSearchNavigation(root: RefObject<HTMLDivElement | null>, itemId: string | undefined, target: TimelineSearchTarget | null | undefined, releasePin: () => void, revision: unknown): void;

package/dist/components/timeline-settlement.d.ts

@@ -0,0 +1,16 @@
+import type { TimelineGroup } from "../timeline/types.js";
+export type TimelineSettlement = {
+    element: HTMLElement;
+    top: number;
+};
+/** Capture only a retained answer at a real live→settled boundary, never history load. */
+export declare function captureTimelineSettlement(scroller: HTMLElement, groups: readonly {
+    key: string;
+    group: TimelineGroup;
+}[]): TimelineSettlement | null;
+/**
+ * Folding earlier prose can clamp scrollTop before paint. Keep the retained
+ * answer visually continuous after the normal scroll authority has run. This
+ * is one local position transition, not a new scroll writer or a presence tree.
+ */
+export declare function animateTimelineSettlement(snapshot: TimelineSettlement): Animation | null;

package/dist/components/tool-action-review.d.ts

@@ -0,0 +1,47 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+import type { ToolActionReview, ToolReviewDetailsPage } from "@opengeni/sdk";
+export type ToolReviewDetailsLoader = (review: ToolActionReview, path: string, offset: number) => Promise<ToolReviewDetailsPage>;
+type Tone = "waiting" | "ok" | "failed" | "muted";
+/** Shown when an older request's saved values are gone: approval is impossible, decline is not. */
+export declare const UNRECOVERABLE_TEXT = "The details of this older request couldn't be recovered, so it can't be approved. Decline it to let the agent continue.";
+/** Card chrome shared by the review, its loading state and its load failure. */
+export declare function ToolReviewFrame({ tone, icon, eyebrow, title, titleId, subtitle, children, footer, bare, ...rest }: {
+    tone: Tone;
+    icon: ReactNode;
+    eyebrow: ReactNode;
+    title: ReactNode;
+    titleId?: string | undefined;
+    subtitle?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    bare?: boolean | undefined;
+} & Omit<HTMLAttributes<HTMLElement>, "title">): import("react").JSX.Element;
+export declare function DeclineButton({ busy, submitting, label, onClick, }: {
+    busy: boolean;
+    submitting: boolean;
+    label?: string | undefined;
+    onClick: () => void;
+}): import("react").JSX.Element;
+/** One host-neutral review. All callbacks refer to the immutable action; none can edit it. */
+export declare function ToolActionReviewCard({ review, onApprove, onReject, submitting, disabled, onViewDetails, pendingLabel, rejectLabel, bare, }: {
+    review: ToolActionReview;
+    onApprove?: (() => void) | undefined;
+    onReject?: (() => void) | undefined;
+    submitting?: "approve" | "reject" | null | undefined;
+    disabled?: boolean | undefined;
+    onViewDetails?: ((path: string) => void) | undefined;
+    pendingLabel?: string | undefined;
+    rejectLabel?: string | undefined;
+    /** Render without card chrome, e.g. inside an expanded timeline row. */
+    bare?: boolean | undefined;
+}): import("react").JSX.Element;
+/** Full-page detail content: hosts choose navigation, never a nested scrolling panel. */
+export declare function ToolActionReviewDetails({ review, path: initialPath, load, onBack, manageFocus, }: {
+    review: ToolActionReview;
+    path?: string;
+    load: ToolReviewDetailsLoader;
+    onBack: () => void;
+    /** Hosts rendering simultaneous previews can retain their own focus. */
+    manageFocus?: boolean;
+}): import("react").JSX.Element;
+export {};

package/dist/components/tool-review-history.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+import type { SessionEvent, ToolActionReview } from "@opengeni/sdk";
+type HistoryContext = {
+    approvalIds: ReadonlySet<string>;
+    revision: number;
+    load: (approvalId: string) => Promise<ToolActionReview>;
+    onViewDetails: (review: ToolActionReview, path: string) => void;
+};
+/** Opt-in, authenticated history for the exact reviewed calls in the visible event window. */
+export declare function ToolReviewHistoryProvider({ events, load, onViewDetails, children, }: {
+    events: readonly SessionEvent[];
+    load: HistoryContext["load"];
+    onViewDetails: HistoryContext["onViewDetails"];
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useHasToolReview(approvalId: string | null): boolean;
+/**
+ * The saved review for one recorded call, or null while it loads or when it is
+ * unavailable (callers then keep their ordinary tool row).
+ */
+export declare function useRecordedToolReview(approvalId: string | null): {
+    review: ToolActionReview | null;
+    onViewDetails: ((path: string) => void) | undefined;
+};
+export {};

package/dist/components/usage-limit-notice.d.ts

@@ -0,0 +1,49 @@
+import type { UsageAllowancePeriod, WorkspaceUsageResponse } from "@opengeni/sdk/usage-allowances";
+import { type ReactNode } from "react";
+import { type UsageClientLike } from "../hooks/use-usage.js";
+import { type AllowanceLabels } from "../usage/allowance-copy.js";
+import { type UsageSummary } from "../usage/summary.js";
+export type UsageLimitNoticeLabels = AllowanceLabels & {
+    /** "You've used 85% of your usage limit." */
+    memberWarning: (percent: string) => string;
+    /** "This workspace has used 85% of its usage budget." */
+    workspaceWarning: (percent: string) => string;
+    memberExhausted: string;
+    workspaceExhausted: string;
+    dismiss: string;
+};
+export declare const DEFAULT_USAGE_LIMIT_NOTICE_LABELS: UsageLimitNoticeLabels;
+type NoticeBaseProps = {
+    labels?: Partial<UsageLimitNoticeLabels> | undefined;
+    /**
+     * Your own next step beside the message, for example an "Upgrade" or
+     * "Request more" button. Receives the summary so it can differ by scope.
+     */
+    action?: ((summary: UsageSummary) => ReactNode) | undefined;
+    /**
+     * Remember a dismissed warning for this browser tab. The key should name the
+     * workspace; the period and scope are added for you, so a new warning (or a
+     * new period) shows again. Reaching the limit is never dismissible.
+     */
+    dismissStorageKey?: string | undefined;
+    className?: string | undefined;
+};
+export type UsageLimitNoticeProps = NoticeBaseProps & {
+    /** A usage response you already loaded; omit it to read `/usage/me`. */
+    usage?: WorkspaceUsageResponse | null | undefined;
+    client?: UsageClientLike | undefined;
+    workspaceId?: string | undefined;
+    period?: UsageAllowancePeriod | undefined;
+    refreshKey?: unknown;
+};
+/**
+ * A calm line for the composer when a member is close to, or at, a usage
+ * limit: what happened, who can raise it, and when it resets. Renders nothing
+ * while usage is comfortable, unlimited, loading, or unreadable.
+ */
+export declare function UsageLimitNotice({ usage, client, workspaceId, period, refreshKey, ...view }: UsageLimitNoticeProps): import("react").JSX.Element;
+/** Presentational notice for a summary you computed (`summarizeUsage`). */
+export declare function UsageLimitNoticeView({ summary, labels: overrides, action, dismissStorageKey, className, }: NoticeBaseProps & {
+    summary: UsageSummary | null;
+}): import("react").JSX.Element | null;
+export {};

package/dist/components/usage-member-list.d.ts

@@ -0,0 +1,91 @@
+import type { MemberAllowanceDefault, MemberAllowanceRule, MemberAllowanceUsage, WorkspaceUsageResponse } from "@opengeni/sdk/usage-allowances";
+/** How a member is named in the list. Usage rows carry only a subject id. */
+export type UsageMemberIdentity = {
+    name: string;
+    /** A second line: an email, a role, or "You". */
+    detail?: string | null | undefined;
+};
+/**
+ * Opt in to fixed-amount limits. Amounts are USD micros on the wire; your
+ * format/parse decide the unit people type ("$50.00", "500 credits").
+ */
+export type UsageAmountFormat = {
+    format: (micros: number) => string;
+    /** Returns micros, or null when the text is not a valid amount. */
+    parse: (text: string) => number | null;
+    /** Shown before the input, for example "$". */
+    prefix?: string | undefined;
+    /** The amount input's step in the person's unit. */
+    step?: number | undefined;
+};
+export type UsageMemberListLabels = {
+    listLabel: string;
+    used: (percent: string) => string;
+    noLimitUsed: string;
+    amounts: (used: string, limit: string) => string;
+    nearLimit: string;
+    limitReached: string;
+    limit: string;
+    defaultEqualShare: (percent: string) => string;
+    defaultNone: string;
+    defaultShare: (percent: string) => string;
+    defaultAmount: (amount: string) => string;
+    share: (percent: string) => string;
+    amount: (amount: string) => string;
+    fixedAmountHidden: string;
+    edit: (name: string) => string;
+    editorTitle: (name: string) => string;
+    optionDefault: string;
+    optionShare: string;
+    optionAmount: string;
+    fixedAmountHint: string;
+    shareSlider: string;
+    shareInput: string;
+    amountInput: string;
+    equalShareMultiple: (multiple: string) => string;
+    sameAsEqualShare: string;
+    atBudget: (amount: string) => string;
+    save: string;
+    saving: string;
+    cancel: string;
+    saveFailed: string;
+    invalidAmount: string;
+    totalWithin: (percent: string) => string;
+    totalOver: (percent: string) => string;
+    oversubscribedHelp: string;
+    unlimitedMembers: (count: number) => string;
+    empty: string;
+};
+export declare const DEFAULT_USAGE_MEMBER_LIST_LABELS: UsageMemberListLabels;
+export type UsageMemberListProps = {
+    /** The full roster for one period (`getAllUsage` / every `getUsage` page). */
+    usage: WorkspaceUsageResponse;
+    /** The workspace's `memberDefault`, to name what "default" means. */
+    memberDefault?: MemberAllowanceDefault | null | undefined;
+    /** Name a member. Defaults to the external id, then the subject id. */
+    describe?: ((member: MemberAllowanceUsage) => UsageMemberIdentity) | undefined;
+    /**
+     * Save a member's rule (`null` restores the default). Omit for a read-only
+     * list. Run it on your backend: member limits need workspace admin authority.
+     */
+    onChangeRule?: ((member: MemberAllowanceUsage, rule: MemberAllowanceRule) => Promise<void>) | undefined;
+    /** Opt in to amounts and fixed-amount limits. Shares only without it. */
+    amounts?: UsageAmountFormat | undefined;
+    labels?: Partial<UsageMemberListLabels> | undefined;
+    /** Draw the list's own border. Turn off inside a card that already has one. */
+    framed?: boolean | undefined;
+    className?: string | undefined;
+};
+/** Words for a member's current limit, from their override or the default. */
+export declare function describeMemberLimit(member: Pick<MemberAllowanceUsage, "rule" | "limit">, context: {
+    memberDefault: MemberAllowanceDefault | null | undefined;
+    shareBase: number;
+    amounts?: UsageAmountFormat | undefined;
+    labels?: Partial<UsageMemberListLabels> | undefined;
+}): string;
+/**
+ * Every member's usage against their own limit, with an optional editor:
+ * a share-of-budget slider (default), a fixed amount, or the workspace
+ * default. Oversubscription is shown, never blocked.
+ */
+export declare function UsageMemberList({ usage, memberDefault, describe, onChangeRule, amounts, labels: overrides, framed, className, }: UsageMemberListProps): import("react").JSX.Element;

package/dist/components/usage-meter.d.ts

@@ -0,0 +1,73 @@
+import type { UsageAllowancePeriod, WorkspaceUsageResponse } from "@opengeni/sdk/usage-allowances";
+import { type UsageClientLike } from "../hooks/use-usage.js";
+import { type AllowanceLabels } from "../usage/allowance-copy.js";
+import { type UsageSummary } from "../usage/summary.js";
+export type UsageMeterLabels = AllowanceLabels & {
+    /** Heading for the member's own ceiling. */
+    title: string;
+    /** Heading when only the shared workspace pool applies. */
+    workspaceTitle: string;
+    /** "38% left" — `percent` is preformatted ("38", "<1"). */
+    left: (percent: string) => string;
+    /** "62% used". */
+    used: (percent: string) => string;
+    limitReached: string;
+    /** Status chip beside a hero meter that is close to its limit. */
+    nearLimit: string;
+    /** "$13.00 left" for a hero meter with amounts. */
+    amountLeft: (amount: string) => string;
+    /** No ceiling applies to this member. */
+    unlimited: string;
+    loading: string;
+    error: string;
+    retry: string;
+    /** "$31.00 of $50.00 used" when the host passes `formatAmount`. */
+    amounts: (used: string, limit: string) => string;
+    /** The shared pool, under a member's own meter: "Workspace: 9% left". */
+    workspaceLine: (value: string) => string;
+};
+export declare const DEFAULT_USAGE_METER_LABELS: UsageMeterLabels;
+export type UsageMeterBaseProps = {
+    /** "left" (default) reads like a battery; "used" reads like spend. */
+    measure?: "left" | "used" | undefined;
+    /**
+     * Opt in to amounts. Receives USD micros; return your own unit ("$31.00",
+     * "3.1 credits", "1.5× plan"). Without it the meter shows only shares.
+     */
+    formatAmount?: ((micros: number) => string) | undefined;
+    labels?: Partial<UsageMeterLabels> | undefined;
+    /**
+     * `compact` is one line for menus and headers; `hero` leads a page with the
+     * amount (or share) left in large type. An empty `labels.title` hides the
+     * heading when the page already names it.
+     */
+    density?: "default" | "compact" | "hero" | undefined;
+    /** Show the shared pool under the member's own meter when it is the tighter one. Default true. */
+    showWorkspace?: boolean | undefined;
+    className?: string | undefined;
+};
+export type UsageMeterProps = UsageMeterBaseProps & {
+    /**
+     * A usage response you already loaded (for example from `useUsage`).
+     * Omit it to let the meter read `/usage/me` itself.
+     */
+    usage?: WorkspaceUsageResponse | null | undefined;
+    client?: UsageClientLike | undefined;
+    workspaceId?: string | undefined;
+    period?: UsageAllowancePeriod | undefined;
+    /** Re-read when this changes (see `useUsage`). */
+    refreshKey?: unknown;
+};
+/**
+ * The signed-in member's own usage: how much of their limit is left and when
+ * it resets. Shares only by default; hosts opt in to amounts.
+ */
+export declare function UsageMeter({ usage, client, workspaceId, period, refreshKey, ...view }: UsageMeterProps): import("react").JSX.Element;
+export type UsageMeterViewProps = UsageMeterBaseProps & {
+    summary: UsageSummary | null;
+    loading?: boolean | undefined;
+    error?: Error | null | undefined;
+    onRetry?: (() => void) | undefined;
+};
+/** Presentational meter for a summary you computed (`summarizeUsage`). */
+export declare function UsageMeterView({ summary, loading, error, onRetry, measure, formatAmount, labels: overrides, density, showWorkspace, className, }: UsageMeterViewProps): import("react").JSX.Element;

package/dist/components/use-viewer-menu-dismiss.d.ts

@@ -0,0 +1,2 @@
+/** Keep native details menus dismissible without letting Escape close the dock. */
+export declare function useViewerMenuDismiss(enabled?: boolean): import("react").RefObject<HTMLDetailsElement | null>;

package/dist/components/user-message-body.d.ts

@@ -1,6 +1,13 @@
 import { type ReactNode } from "react";
 type RestoreDisclosureAnchor = (() => void) | null;
+export type UserMessageDisclosureLabels = {
+    /** Collapsed disclosure action. Defaults to "Show more". */
+    showMore?: string | undefined;
+    /** Expanded disclosure action. Defaults to "Show less". */
+    showLess?: string | undefined;
+};
 export type UserMessageDisclosureContextValue = {
+    labels?: UserMessageDisclosureLabels | undefined;
     expandedByMessageId: Map<string, boolean>;
     beginChange: (messageBody: HTMLElement, disclosureControl: HTMLElement) => RestoreDisclosureAnchor;
 };
@@ -21,6 +28,8 @@ export type UserMessageBodyProps = {
     text: string;
     children: ReactNode;
     className?: string | undefined;
+    /** Per-field overrides for timeline labels, then the English defaults. */
+    disclosureLabels?: UserMessageDisclosureLabels | undefined;
 };
 /**
  * Lossless disclosure boundary for already-sent user-message text.
@@ -32,5 +41,5 @@ export type UserMessageBodyProps = {
  * remembers expansion per durable message id and preserves the reader's scroll
  * anchor when height changes.
  */
-export declare function UserMessageBody({ messageId, text, children, className }: UserMessageBodyProps): import("react").JSX.Element;
+export declare function UserMessageBody({ messageId, text, children, className, disclosureLabels, }: UserMessageBodyProps): import("react").JSX.Element;
 export {};