@gearbox-protocol/ui-kit 4.0.0-next.8 → 4.0.0-next.80

package/dist/types/components/base/more-accordion/more-accordion.d.ts

@@ -7,5 +7,10 @@ export interface MoreAccordionProps {
     readonly moreMessage?: TitleText;
     readonly lessMessage?: TitleText;
 }
-/** Centered more/less disclosure over a `SimpleAccordion`. */
+/**
+ * Centered more/less disclosure over a `SimpleAccordion`.
+ *
+ * Nothing renders it yet, in the kit or in either consumer: kept as part of the
+ * base layer on purpose.
+ */
 export declare function MoreAccordion({ children, moreMessage, lessMessage, }: MoreAccordionProps): React.ReactElement;

package/dist/types/components/base/pool-apy-breakdown-card/constants.d.ts

@@ -1,4 +1,7 @@
 export declare class PoolApyBreakdownCardTest {
     static root: string;
+    static net: string;
     static value: string;
+    static reward: string;
+    static points: string;
 }

package/dist/types/components/base/pool-apy-breakdown-card/pool-apy-breakdown-card.d.ts

@@ -1,13 +1,18 @@
-import { Bps } from '@gearbox-protocol/sdk/model';
+import { ApyBreakdown } from '@gearbox-protocol/sdk/model';
 import { default as React } from 'react';
 import { PoolApyBreakdownCardTest } from './constants';
 export { PoolApyBreakdownCardTest };
 export interface PoolApyBreakdownCardProps {
-    /** Organic and incentive APYs in basis points; a missing value renders a dash. */
-    readonly data?: {
-        readonly organicApy?: Bps;
-        readonly incentiveApy?: Bps;
-    };
+    /** SDK supply APY; missing data renders dashes, a present one with no incentives renders Incentive APY as 0%. */
+    readonly data?: ApyBreakdown;
+    /** When `"7d"`, labels carry the averaging-window suffix. */
+    readonly period?: "7d";
 }
-/** Organic vs incentive APY next to the pool APY chart. Missing values render as dashes. */
-export declare function PoolApyBreakdownCard({ data, }: PoolApyBreakdownCardProps): React.ReactElement;
+/**
+ * How a pool's net APY is arrived at: base yield plus incentives.
+ *
+ * A token reward names the incentive row (`GEAR Incentive APY`). With none,
+ * that row is still shown as Incentive APY at 0%. Points sit under a divider
+ * when present; they are not addends.
+ */
+export declare function PoolApyBreakdownCard({ data, period, }: PoolApyBreakdownCardProps): React.ReactElement;

package/dist/types/components/base/position-assets/constants.d.ts

@@ -0,0 +1,6 @@
+export declare class PositionAssetsTest {
+    static root: string;
+    static row: string;
+    static worth: string;
+    static empty: string;
+}

package/dist/types/components/base/position-assets/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './position-assets';

package/dist/types/components/base/position-assets/position-asset-rows.d.ts

@@ -0,0 +1,23 @@
+import { TokenAmount } from '@gearbox-protocol/sdk/model';
+/** One token across both sides of a change. */
+export interface AssetRow {
+    readonly token: TokenAmount["token"];
+    /** What the position holds now — zero for a token only the other side has. */
+    readonly value: bigint;
+    /** What it becomes — zero where the projection drops the token. */
+    readonly valueTo: bigint;
+    /**
+     * What the token is worth at its richer side, which is what decides both
+     * dust and order. `null` when a side the oracle cannot price is involved.
+     */
+    readonly worth: number | null;
+    /** USD of the "now" side; `null` where the oracle could not price it. */
+    readonly valueUsd: number | null;
+    /** USD of the "after" side, for the caption a paired row shows. */
+    readonly valueToUsd: number | null;
+}
+/**
+ * What earns a row, most valuable first — decided across both sides, so a
+ * token either side holds is listed once, in one place.
+ */
+export declare function visibleAssets(assets: readonly TokenAmount[] | undefined, to?: readonly TokenAmount[]): AssetRow[];

package/dist/types/components/base/position-assets/position-assets.d.ts

@@ -0,0 +1,47 @@
+import { TokenAmount } from '@gearbox-protocol/sdk/model';
+import { default as React } from 'react';
+import { PositionAssetsTest } from './constants';
+export { PositionAssetsTest };
+export interface PositionAssetsProps {
+    /** What the position holds. */
+    readonly assets?: readonly TokenAmount[];
+    /**
+     * What those holdings become. Given, every row reads `before → after` and
+     * names its token once for the pair; omitted, the rows are plain holdings.
+     */
+    readonly to?: readonly TokenAmount[];
+    /** Rendered in place of the rows when nothing survives the dust filter. */
+    readonly empty?: React.ReactNode;
+    /**
+     * Prefixes the projected amount with {@link APPROXIMATE_SYMBOL} — the "after"
+     * of a pair, or the only column when the list itself is a projection. The
+     * struck "before" is never marked: it is what the account holds now.
+     */
+    readonly approximate?: boolean;
+    readonly testId?: string;
+}
+/**
+ * Holdings token by token, most valuable first — the position itself rather
+ * than the one number its collateral adds up to. A right-aligned column, so it
+ * reads as the value of the `InfoLine` a caller drops it into.
+ *
+ * The whole of a change belongs in the one slot: a row carries both amounts
+ * with the arrow between them, rather than the caller putting one list in
+ * `value` and another in `valueTo`. Two lists would name the same token twice
+ * and draw its icon twice, which is what pushes a long symbol out of a narrow
+ * dialog; they would also have to be kept in the same order by hand.
+ *
+ * The rows carry no label of their own, which is why they are not `InfoLine`s:
+ * `VerticalIndicator` leaves out its left column entirely when no label is
+ * given and never justifies what remains, so a label-less row would sit on the
+ * wrong side.
+ *
+ * Dust is left out: an account carries stray fractions of a cent from
+ * rounding, and listing them buries the holdings that matter. A token the
+ * oracle cannot price is never dust — an unknown value is not a small one.
+ */
+export declare function PositionAssets({ assets, to, empty, approximate, testId, }: PositionAssetsProps): React.ReactElement;
+/**
+ * The larger of two sides' USD. An unpriced side wins over any number: it is
+ * an unknown value, not a small one, and must not be called dust.
+ */

package/dist/types/components/base/review-button/constants.d.ts

@@ -1,4 +1,5 @@
 export declare class ReviewButtonTest {
     static root: string;
     static error: string;
+    static tip: string;
 }

package/dist/types/components/base/review-button/review-button.d.ts

@@ -1,13 +1,27 @@
 import { default as React } from 'react';
+import { FormattedMessageTypedProps } from '../../typed-intl';
 import { LocaleKeys } from '../../../locale';
 import { ReviewButtonTest } from './constants';
 export { ReviewButtonTest };
 export interface ReviewButtonProps {
     readonly disabled: boolean;
-    /** Message id of what blocks the action; rendered above the button. */
+    /** What blocks the action; takes the button's own label while it is set. */
     readonly error: LocaleKeys | null;
+    /**
+     * How to get past the error — a card above the button. Taken as a message
+     * rather than a node because this component owns the formatter: the numbers
+     * a resolution names are `values`, and every caller would otherwise repeat
+     * the same `<FormattedMessageTyped>` wrapper.
+     */
+    readonly tip?: FormattedMessageTypedProps;
     readonly onClick: () => void;
     readonly label?: LocaleKeys;
 }
-/** The single primary action of every dialog: review, then confirm in Verify. */
-export declare function ReviewButton({ disabled, error, onClick, label, }: ReviewButtonProps): React.ReactElement;
+/**
+ * The single primary action of every dialog: review, then confirm in Verify.
+ *
+ * A blocked action says so on the button itself, and says what to do about it
+ * above — the arrangement the confirm screen already uses, so a dialog and its
+ * confirmation report the same refusal the same way.
+ */
+export declare function ReviewButton({ disabled, error, tip, onClick, label, }: ReviewButtonProps): React.ReactElement;

package/dist/types/components/base/segmented-tabs/segmented-tabs-styles.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Gray pill styling shared with sibling controls (e.g. the ManagePane "…"
+ * button). Its own module so the barrel carries the component, not its classes.
+ */
+export declare const SEGMENTED_TABS_INACTIVE_BUTTON_CLASS = "bg-gray-30 border-gray-30 hover:bg-gray-40 hover:border-gray-40";

package/dist/types/components/base/segmented-tabs/segmented-tabs.d.ts

@@ -1,8 +1,6 @@
 import { default as React } from 'react';
 import { SegmentedTabsTest } from './constants';
 export { SegmentedTabsTest };
-/** Gray pill styling shared with sibling controls (e.g. the ManagePane "…" button). */
-export declare const SEGMENTED_TABS_INACTIVE_BUTTON_CLASS = "bg-gray-30 border-gray-30 hover:bg-gray-40 hover:border-gray-40";
 export interface SegmentedTabsItem<T extends string> {
     readonly id: T;
     readonly item: React.ReactNode;

package/dist/types/components/base/stat-badge/constants.d.ts

@@ -2,4 +2,5 @@ export declare class StatBadgeTest {
     static root: string;
     static grid: string;
     static action: string;
+    static delta: string;
 }

package/dist/types/components/base/stat-badge/stat-badge.d.ts

@@ -3,10 +3,20 @@ import { TitleText } from '../text';
 import { StatBadgeTest } from './constants';
 export { StatBadgeTest };
 export type StatBadgeSize = "sm" | "md" | "default";
+export interface StatBadgeDelta {
+    /** Formatted change, e.g. `"12.50%"`. Sign is taken from `value`, not this string. */
+    readonly label: ReactNode;
+    /** Signed change; `> 0` is success, `< 0` is destructive. */
+    readonly value: number;
+    /** Period hint shown on hover, e.g. `"7D"`. */
+    readonly tooltip?: ReactNode;
+}
 export interface StatBadgeProps {
     /** A messageId (formatted here) or a node. */
     readonly title: TitleText;
     readonly value: React.ReactNode;
+    /** Optional change chip in the top-right of the card. Hidden while `isLoading`. */
+    readonly delta?: StatBadgeDelta;
     /** Optional control in the top-right of the card, e.g. a Claim button. */
     readonly action?: ReactNode;
     readonly className?: string;
@@ -16,7 +26,7 @@ export interface StatBadgeProps {
     readonly testId?: string;
     readonly size?: StatBadgeSize;
 }
-export declare function StatBadge({ title, value, isLoading, size, action, className, testId, }: StatBadgeProps): React.ReactElement;
+export declare function StatBadge({ title, value, isLoading, size, delta, action, className, testId, }: StatBadgeProps): React.ReactElement;
 export interface StatBadgeGridProps {
     readonly cols?: 1 | 2 | 3 | 4;
     readonly colsLg?: 1 | 2 | 3 | 4;

package/dist/types/components/base/strategy-apy-breakdown-card/constants.d.ts

@@ -1,5 +1,9 @@
 export declare class StrategyApyBreakdownCardTest {
     static root: string;
-    static row: string;
     static net: string;
+    static collateral: string;
+    static borrow: string;
+    static value: string;
+    static points: string;
+    static caption: string;
 }

package/dist/types/components/base/strategy-apy-breakdown-card/strategy-apy-breakdown-card.d.ts

@@ -1,17 +1,45 @@
-import { ApyBreakdown, Bps, Leverage } from '@gearbox-protocol/sdk/model';
+import { Leverage, StrategyOpportunity } from '@gearbox-protocol/sdk/model';
 import { default as React } from 'react';
 import { StrategyApyBreakdownCardTest } from './constants';
 export { StrategyApyBreakdownCardTest };
-export interface StrategyApyBreakdownData {
-    readonly collateralApy?: ApyBreakdown;
-    readonly borrowApy?: Bps;
-    readonly additionalBorrowApy?: Bps;
-    readonly maxLeverage?: Leverage;
-}
+/**
+ * What the card reads off a strategy: the seven-day feed, and the liquidation
+ * threshold the quota is weighted by.
+ *
+ * A slice of the SDK type rather than a shape of its own, so a caller hands
+ * over the opportunity it already holds and the card states what it reads.
+ */
+export type StrategyApyBreakdownSlice = Pick<StrategyOpportunity, "borrowApyAvg7D" | "quotaRateAvg7D" | "liquidationThreshold" | "collateralApyAvg7D">;
 export interface StrategyApyBreakdownCardProps {
-    readonly data: StrategyApyBreakdownData;
-    /** Selected leverage from the chart toolbar chips. Falls back to max. */
-    readonly leverage?: Leverage;
+    /** The strategy being broken down; every figure is derived from it. */
+    readonly data: StrategyApyBreakdownSlice;
+    /** Leverage every figure below is quoted at. */
+    readonly leverage: Leverage;
+    /**
+     * Multiplier caption under each figure — `11.18 × 3.11%` and the like.
+     *
+     * On beside a chart, where the card is the derivation and there is room for
+     * it. Off in a tooltip, where it is a glance.
+     */
+    readonly showFormula?: boolean;
+    /** When `"7d"`, labels carry the averaging-window suffix. */
+    readonly period?: "7d";
 }
-/** Net APY formula beside the strategy yield chart. Chart itself is unchanged. */
-export declare function StrategyApyBreakdownCard({ data, leverage: leverageProp, }: StrategyApyBreakdownCardProps): React.ReactElement;
+/**
+ * How a strategy's net APY is arrived at: collateral yield on the leveraged
+ * position, less what the credit behind it costs.
+ *
+ * The card is handed a strategy and a leverage and derives the rest, because
+ * every figure it shows is a figure only this card asks for. **N** and **B**
+ * come from the SDK — `calcNetStrategyApy` and `calcEffectiveBorrowApy`, the
+ * same two the badge and the list cell are quoting — and the collateral row is
+ * their sum, which is exactly `round(leverage × collateralApy)` because the SDK
+ * subtracts an integer `B` inside its own rounding. Deriving the third value
+ * instead of recomputing it is what makes `N = C − B` hold to the basis point
+ * rather than approximately.
+ *
+ * Incentive rows are levered individually and the collateral row takes the
+ * remainder, so the column adds up to the chip even when each reward rounds
+ * its own way.
+ */
+export declare function StrategyApyBreakdownCard({ data, leverage, showFormula, period, }: StrategyApyBreakdownCardProps): React.ReactElement;

package/dist/types/components/base/tabber/index.d.ts

@@ -1,2 +1 @@
 export * from './tabber';
-export * from './use-detail-scroll-spy';

package/dist/types/components/base/tabber/is-tabber.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+/**
+ * Whether a node is a Tabber, so DetailsView can tell a tabbed pane from plain
+ * content. Its own module: the barrel carries the component, not the predicate.
+ */
+export declare function isTabber(node: ReactNode): boolean;

package/dist/types/components/base/tabber/tabber.d.ts

@@ -10,8 +10,8 @@ export interface TabberSectionProps {
     readonly actions?: React.ReactNode;
     readonly children?: React.ReactNode;
     /**
-     * Render this section above the sticky tab bar (overview badges). The tab
-     * still appears in the bar and scroll-spy still tracks the section.
+     * Render this section above the sticky tab bar (overview badges). The
+     * section is not listed in the bar; scroll-spy tracks only sections below it.
      */
     readonly beforeBar?: boolean;
     /** Skip the in-section h2 — overview has badges, not a heading. */
@@ -30,4 +30,3 @@ export interface TabberProps {
     readonly mobileManagePane?: React.ReactNode;
 }
 export declare function Tabber({ children, observeKey, initialSection, testId, mobileManagePane, }: TabberProps): React.ReactElement;
-export declare function isTabber(node: React.ReactNode): boolean;

package/dist/types/components/base/time-to-liquidation-block/time-to-liquidation-block.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
 import { TitleText } from '../text';
-import { TTLZones } from '../../../utils/ttl';
+import { TTLZones } from './ttl';
 import { TimeToLiquidationBlockTest } from './constants';
 export { TimeToLiquidationBlockTest };
 export interface TimeToLiquidationBlockProps {
@@ -11,6 +11,13 @@ export interface TimeToLiquidationBlockProps {
     readonly data?: bigint | null;
     /** Time after the operation; renders a from → to transition. */
     readonly dataTo?: bigint | null;
+    /**
+     * Prefixes the figure with {@link APPROXIMATE_SYMBOL}, for a value the
+     * operation projects rather than promises. Only the projected side is
+     * marked: on a `from → to` row the "from" is where the account stands now,
+     * which is measured, not estimated.
+     */
+    readonly approximate?: boolean;
     /** Pre-computed zone; if not set, derived from the value. */
     readonly zone?: TTLZones;
     readonly isLoading?: boolean;
@@ -24,4 +31,4 @@ export interface TimeToLiquidationBlockProps {
  * "Time to liquidation" row of a preview: label + help tip, the remaining
  * time as `Nmo` / `Nd` / `<1d` with a zone dot, optionally from → to.
  */
-export declare function TimeToLiquidationBlock({ data, dataTo, zone, isLoading, title, tip, testId, }: TimeToLiquidationBlockProps): React.ReactElement;
+export declare function TimeToLiquidationBlock({ data, dataTo, approximate, zone, isLoading, title, tip, testId, }: TimeToLiquidationBlockProps): React.ReactElement;

package/dist/types/components/base/time-to-liquidation-block/ttl-left.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Result of ttlLeftParsed function
+ */
+export type TTLLeftResult = {
+    months: number;
+    day?: never;
+} | {
+    day: number;
+    months?: never;
+} | undefined;
+/**
+ * Parse TTL into structured object with months or days
+ *
+ * @param ttl - Time to live in milliseconds
+ * @returns Object with months or day property, or undefined if less than 1 day
+ *
+ * @example
+ * ```ts
+ * ttlLeft(100 * DAY) // { months: 3 }
+ * ttlLeft(15 * DAY)  // { day: 15 }
+ * ttlLeft(12 * HOUR) // undefined
+ * ```
+ */
+export declare function ttlLeft(ttl: number | bigint): TTLLeftResult;

package/dist/types/components/base/time-to-liquidation-block/ttl.d.ts

@@ -0,0 +1,15 @@
+export type TTLZones = "good" | "medium" | "bad";
+/**
+ * Get the TTL zone based on the remaining time
+ *
+ * @param ttl - Time to live in milliseconds
+ * @returns Zone: "good" (>= 30 days), "medium" (> 7 days), "bad" (<= 7 days)
+ *
+ * @example
+ * ```ts
+ * getTTLZones(40 * DAY) // "good"
+ * getTTLZones(14 * DAY) // "medium"
+ * getTTLZones(3 * DAY)  // "bad"
+ * ```
+ */
+export declare function getTTLZones(ttl: number | bigint | undefined): TTLZones | undefined;

package/dist/types/components/base/title-meta/title-meta.d.ts

@@ -1,6 +1,6 @@
 import { Token } from '@gearbox-protocol/sdk/model';
 import { default as React } from 'react';
-import { NetworkIcons } from '../../../utils/network-icons';
+import { NetworkIcons } from '../../../utils/internal/network-icons';
 import { TitleMetaTest } from './constants';
 export { TitleMetaTest };
 export interface TitleMetaLink {

package/dist/types/components/base/token-amount/token-amount.d.ts

@@ -21,7 +21,19 @@ type TokenAmountDataProps = {
     readonly token: Token;
 };
 export type TokenAmountProps = TokenAmountDataProps & {
-    /** Cross-axis alignment of the token line and the USD caption. */
+    /**
+     * Cross-axis alignment of the token line and the USD caption. Defaults to
+     * `end`: nearly every slot this lands in — table cells, info lines, metric
+     * rows — is right-aligned, and a flex column ignores the `text-right` its
+     * wrapper sets. Pass `start` inside a card, where the left edge is right.
+     */
     readonly align?: TokenAmountAlign;
+    /**
+     * Prefixes the token line with {@link APPROXIMATE_SYMBOL}, for a figure the
+     * operation projects rather than promises. The USD caption underneath is not
+     * marked: the mark belongs beside the amount it hedges, and repeating it on
+     * the second line only reads as a second claim.
+     */
+    readonly approximate?: boolean;
 };
-export declare function TokenAmount({ data, token, align, }: TokenAmountProps): React.ReactElement;
+export declare function TokenAmount({ data, token, align, approximate, }: TokenAmountProps): React.ReactElement;

package/dist/types/components/base/values/constants.d.ts

@@ -5,9 +5,11 @@ export declare class ValueTest {
     static utilization: string;
     static healthFactor: string;
     static pnl: string;
+    static priceImpact: string;
     static tokenBigint: string;
     static points: string;
     static placeholder: string;
+    static accruing: string;
 }
 export declare class PositionShortLabelTest {
     static root: string;

package/dist/types/components/base/values/index.d.ts

@@ -1,7 +1,8 @@
-export { ValueTest } from './constants';
-export { PnlValue } from './pnl-value';
-export { PointsValue, type PointsValueProps } from './points-value';
-export { PositionShortLabel, PositionShortLabelTest, } from './position-short-label';
-export { type PositionStatus, PositionStatusBadge, type PositionStatusBadgeProps, } from './position-status-badge';
-export { PositionTypeBadge, type PositionTypeBadgeProps, } from './position-type-badge';
-export { ApyValue, type ApyValueProps, bps, HealthFactorValue, LeverageValue, TokenBigint, UsdValue, UtilizationValue, } from './scalars';
+export * from '../../no-value';
+export * from './constants';
+export * from './pnl-value';
+export * from './position-short-label';
+export * from './position-status-badge';
+export * from './position-type-badge';
+export * from './price-impact-value';
+export * from './scalars';

package/dist/types/components/base/values/pnl-value.d.ts

@@ -1,6 +1,12 @@
 import { PnlBreakdown } from '@gearbox-protocol/sdk/model';
 import { default as React } from 'react';
-/** Realised + unrealised PnL of a position, signed. */
+/**
+ * Realised + unrealised PnL, signed.
+ *
+ * A breakdown (a position's own) or a bare USD figure (a wallet's total, which
+ * the model carries as a plain number) — the same pairing {@link ApyValue}
+ * makes between a breakdown and a bare rate.
+ */
 export declare function PnlValue({ data, }: {
-    readonly data: PnlBreakdown | undefined;
+    readonly data: PnlBreakdown | number | null | undefined;
 }): React.ReactElement;

package/dist/types/components/base/values/position-type-badge.d.ts

@@ -6,6 +6,6 @@ export interface PositionTypeBadgeProps {
     readonly size?: "table" | "aside" | "title";
 }
 /**
- * Colored kind label of a position row: "LP" / "Strategy" / "Liquidation".
+ * Colored kind label of a position row: "Lend" / "Leverage" / "Liquidation".
  */
 export declare function PositionTypeBadge({ data, size, }: PositionTypeBadgeProps): React.ReactElement;

package/dist/types/components/base/values/price-impact-value.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+/**
+ * What a routed operation gave up to market depth.
+ *
+ * Which of the three rates a caller shows — against the routed output, the
+ * equity or the position — is the caller's choice; this renders the one it is
+ * handed.
+ */
+export declare function PriceImpactValue({ data, }: {
+    readonly data: bigint | undefined;
+}): React.ReactElement;

package/dist/types/components/base/values/price-impact.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A price impact as a percentage.
+ *
+ * The scale is `PERCENTAGE_FACTOR_1KK` — `1_000_000` is 100%, so `-10_000` is
+ * -1% — the legacy price-impact scale, a hundred times finer than the `Bps`
+ * the rest of this module speaks. The conversion is owned here for the same
+ * reason `bps` owns its own: `percentageTemplate` carries a same-named,
+ * differently-scaled twin, so a shared step would inherit that ambiguity.
+ *
+ * A loss is what this figure almost always is, and it prints its own minus.
+ * Only the rare route that beat the marginal price needs its sign spelled out,
+ * or a gain would read as a loss of the same size.
+ */
+export declare function priceImpact(value: bigint): string;

package/dist/types/components/base/values/scalars.d.ts

@@ -1,24 +1,32 @@
 import { ApyBreakdown, Bps, Leverage, Token } from '@gearbox-protocol/sdk/model';
 import { default as React } from 'react';
-/**
- * Basis points as a percentage (`10000` = 100%); the model's `Bps` is `number`.
- *
- * Self-contained on purpose: `percentageTemplate` (format-money) carries a
- * same-named, oppositely-scaled twin in `templates.tsx` (already-percent
- * input), so a shared bps→percent step here would inherit that ambiguity.
- * `bps` is the one place that owns the conversion.
- */
-export declare function bps(value: Bps): string;
 export interface ApyValueProps {
-    /** A breakdown (tooltip-able) or a bare rate; `undefined` renders a dash. */
+    /** A breakdown (tooltip-able) or a bare rate; `undefined` renders the empty state. */
     readonly data: ApyBreakdown | Bps | undefined;
+    /**
+     * Whether a breakdown carries its yield tooltip on hover. Off where the
+     * figure is already explained — a badge that states one rate, or a figure
+     * wrapped in a tooltip of its own, which would otherwise stack two.
+     *
+     * A bare `Bps` has no tooltip to begin with, so this does not reach it.
+     *
+     * @default true
+     */
+    readonly tooltip?: boolean;
+    /**
+     * The averaging window this figure comes from. `"7d"` suffixes the breakdown
+     * tooltip labels — and, when the rate is missing, says the average is still
+     * accruing rather than printing a dash. A spot figure keeps the dash: history
+     * has nothing to do with why it is absent.
+     */
+    readonly period?: "7d";
 }
 /**
  * Any APY the model carries, in one place: `supplyApy`, `netApy`, `borrowApy`.
  * A breakdown renders the reference chip (reward icons + breakdown tooltip)
  * via `CompoundAPY`; a bare `Bps` stays a plain percentage.
  */
-export declare function ApyValue({ data }: ApyValueProps): React.ReactElement;
+export declare function ApyValue({ data, tooltip, period, }: ApyValueProps): React.ReactElement;
 export declare function UsdValue({ data, }: {
     readonly data: number | null | undefined;
 }): React.ReactElement;
@@ -28,16 +36,30 @@ export declare function LeverageValue({ data, }: {
 export declare function UtilizationValue({ data, }: {
     readonly data: Bps | undefined;
 }): React.ReactElement;
-/** Health factor with its zone: below 1 the account is liquidatable. */
-export declare function HealthFactorValue({ data, }: {
+/**
+ * Health factor with its zone: below 1 the account is liquidatable. A `debt` of
+ * `0n` drops the zone — a repaid account still reports a figure, and it reads
+ * as the worst there is.
+ */
+export declare function HealthFactorValue({ data, debt, }: {
     readonly data: Bps | undefined;
+    readonly debt?: bigint;
 }): React.ReactElement;
 /**
  * A bare `bigint` in token units (simulate previews carry these): the only
  * value component that needs a denomination passed with it, because the SDK
  * hands these out without one.
+ *
+ * Shown to `formatAssetAmount`'s three decimals, with the exact amount in a
+ * tooltip — a metrics row reads better short, and nothing is lost: the figure
+ * behind the rounding stays a hover away.
  */
-export declare function TokenBigint({ data, token, }: {
+export declare function TokenBigint({ data, token, showSymbol, }: {
     readonly data: bigint | undefined;
     readonly token: Token | undefined;
+    /**
+     * Off where the row names the token itself — a `before → after` pair prints
+     * the symbol once for both amounts rather than twice.
+     */
+    readonly showSymbol?: boolean;
 }): React.ReactElement;

package/dist/types/components/base-table/base-table-line.d.ts

@@ -1,6 +1,6 @@
 import { default as React, ReactNode } from 'react';
 import { BaseTableColumn } from './types';
-export { BaseTableLineTest } from './constants';
+export * from './constants';
 export interface BaseTableLineProps<TSort extends string = never> {
     readonly columns: ReadonlyArray<BaseTableColumn<TSort>>;
     readonly cells: Readonly<Record<string, ReactNode>>;
@@ -8,8 +8,6 @@ export interface BaseTableLineProps<TSort extends string = never> {
     readonly href?: string;
     readonly disabled?: boolean;
     readonly disabledStyle?: boolean;
-    /** Extra row className, e.g. RWA accent tint. */
-    readonly accentClassName?: string;
     readonly onRowClick?: () => void;
     readonly "data-testid"?: string;
     readonly minHeightClassName?: string;
@@ -18,4 +16,4 @@ export interface BaseTableLineProps<TSort extends string = never> {
  * One row of {@link BaseTable}: desktop cells from the column model, or a
  * stacked mobile card driven by each column's `mobile` role.
  */
-export declare function BaseTableLine<TSort extends string = never>({ columns, cells, last, href, disabled, disabledStyle, accentClassName, onRowClick, "data-testid": testId, minHeightClassName, }: BaseTableLineProps<TSort>): React.ReactElement;
+export declare function BaseTableLine<TSort extends string = never>({ columns, cells, last, href, disabled, disabledStyle, onRowClick, "data-testid": testId, minHeightClassName, }: BaseTableLineProps<TSort>): React.ReactElement;

package/dist/types/components/base-table/base-table.d.ts

@@ -1,7 +1,7 @@
 import { default as React, PropsWithChildren, ReactNode } from 'react';
 import { BaseTableColumn, BaseTableSortApi } from './types';
-export { BaseTableTest } from './constants';
-export type { BaseTableColumn, BaseTableSortApi } from './types';
+export * from './constants';
+export * from './types';
 export interface BaseTableProps<TSort extends string = never> {
     readonly columns: ReadonlyArray<BaseTableColumn<TSort>>;
     readonly isLoading: boolean;