jfs-components 0.1.8 → 0.1.17

package/lib/typescript/src/components/PoweredByLabel/PoweredByLabel.d.ts

@@ -46,6 +46,12 @@ export type PoweredByLabelProps = {
      * (which is decorative) does not need to be announced separately.
      */
     accessibilityLabel?: string;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 };
 /**
  * `PoweredByLabel` renders the small "Powered by RBI-regulated account
@@ -66,6 +72,6 @@ export type PoweredByLabelProps = {
  * @component
  * @param {PoweredByLabelProps} props
  */
-declare function PoweredByLabel({ label, imageSource, imageWidth, imageHeight, imageSlot, modes: propModes, style, textStyle, imageStyle, accessibilityLabel, }: PoweredByLabelProps): import("react/jsx-runtime").JSX.Element;
+declare function PoweredByLabel({ label, imageSource, imageWidth, imageHeight, imageSlot, modes: propModes, style, textStyle, imageStyle, accessibilityLabel, disableTruncation, }: PoweredByLabelProps): import("react/jsx-runtime").JSX.Element;
 export default PoweredByLabel;
 //# sourceMappingURL=PoweredByLabel.d.ts.map

package/lib/typescript/src/components/ProductMerchandisingCard/ProductMerchandisingCard.d.ts

@@ -55,6 +55,12 @@ export interface ProductMerchandisingCardProps {
     style?: StyleProp<ViewStyle>;
     /** Accessibility label for the card. */
     accessibilityLabel?: string;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 }
 /**
  * ProductMerchandisingCard — a full-bleed image card (Figma node 5277:317)
@@ -76,6 +82,6 @@ export interface ProductMerchandisingCardProps {
  * The blur strength is driven by the Figma `blur/minimal` token, mapped to the
  * `GlassFill` 0–100 intensity scale the same way `MediaCard` does.
  */
-declare function ProductMerchandisingCard({ imageSource, title, subtitle, badgeLabel, badge, showAvatar, avatarSource, avatarMonogram, avatar, specialBadgeLabel, specialBadgeIcon, specialBadge, ctaLabel, onCtaPress, cta, onPress, height, modes, style, accessibilityLabel, }: ProductMerchandisingCardProps): import("react/jsx-runtime").JSX.Element;
+declare function ProductMerchandisingCard({ imageSource, title, subtitle, badgeLabel, badge, showAvatar, avatarSource, avatarMonogram, avatar, specialBadgeLabel, specialBadgeIcon, specialBadge, ctaLabel, onCtaPress, cta, onPress, height, modes, style, accessibilityLabel, disableTruncation, }: ProductMerchandisingCardProps): import("react/jsx-runtime").JSX.Element;
 export default ProductMerchandisingCard;
 //# sourceMappingURL=ProductMerchandisingCard.d.ts.map

package/lib/typescript/src/components/ProductOverview/ProductOverview.d.ts

@@ -34,7 +34,13 @@ export type ProductOverviewProps = {
      * for badges, callouts, etc. Receives the same `modes` as the parent.
      */
     children?: React.ReactNode;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 };
-declare const ProductOverview: ({ imageSource, imageRatio, labelImageSource, label, productName, description, stats, modes, style, children, }: ProductOverviewProps) => import("react/jsx-runtime").JSX.Element;
+declare const ProductOverview: ({ imageSource, imageRatio, labelImageSource, label, productName, description, stats, modes, style, children, disableTruncation, }: ProductOverviewProps) => import("react/jsx-runtime").JSX.Element;
 export default ProductOverview;
 //# sourceMappingURL=ProductOverview.d.ts.map

package/lib/typescript/src/components/ProgressBadge/ProgressBadge.d.ts

@@ -16,6 +16,12 @@ export type ProgressBadgeProps = {
     textStyle?: StyleProp<TextStyle>;
     /** Accessibility label for screen readers */
     accessibilityLabel?: string;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 } & React.ComponentProps<typeof View>;
 /**
  * ProgressBadge component that displays an icon, text, and an internal progress bar.
@@ -32,6 +38,6 @@ export type ProgressBadgeProps = {
  * @param {Object} [props.textStyle] - Optional text style overrides.
  * @param {string} [props.accessibilityLabel] - Accessibility label.
  */
-declare function ProgressBadge({ taskName, iconName, value, modes, style, textStyle: textStyleOverride, accessibilityLabel, ...rest }: ProgressBadgeProps): import("react/jsx-runtime").JSX.Element;
+declare function ProgressBadge({ taskName, iconName, value, modes, style, textStyle: textStyleOverride, accessibilityLabel, disableTruncation, ...rest }: ProgressBadgeProps): import("react/jsx-runtime").JSX.Element;
 export default ProgressBadge;
 //# sourceMappingURL=ProgressBadge.d.ts.map

package/lib/typescript/src/components/ProjectionMarker/ProjectionMarker.d.ts

@@ -50,6 +50,12 @@ export type ProjectionMarkerProps = {
     rateStyle?: StyleProp<TextStyle>;
     /** Accessibility label for the whole marker. */
     accessibilityLabel?: string;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 };
 /**
  * ProjectionMarker renders a start value and an end value connected to a
@@ -77,6 +83,6 @@ export type ProjectionMarkerProps = {
  * />
  * ```
  */
-declare function ProjectionMarker({ startValue, endValue, duration, rate, showConnectors, modes, style, startValueStyle, endValueStyle, badgeStyle, durationStyle, rateStyle, accessibilityLabel, }: ProjectionMarkerProps): import("react/jsx-runtime").JSX.Element;
+declare function ProjectionMarker({ startValue, endValue, duration, rate, showConnectors, modes, style, startValueStyle, endValueStyle, badgeStyle, durationStyle, rateStyle, accessibilityLabel, disableTruncation, }: ProjectionMarkerProps): import("react/jsx-runtime").JSX.Element;
 export default ProjectionMarker;
 //# sourceMappingURL=ProjectionMarker.d.ts.map

package/lib/typescript/src/components/SavingsGoalSummary/SavingsGoalSummary.d.ts

@@ -27,6 +27,14 @@ export type SavingsGoalSummaryItem = {
     indicatorColor?: string;
 };
 export type SavingsGoalSummaryProps = {
+    /**
+     * Optional caption rendered directly above the percentage value
+     * (e.g. `"Credit usage"`), matching the Figma `savingsGoalSummary/label`
+     * slot. Pass a string for token-styled text, or any `ReactNode` for full
+     * control. Omit (the default) to hide it — preserving the original
+     * value-only layout for existing callers.
+     */
+    label?: React.ReactNode;
     /**
      * Currency symbol (e.g. `'₹'`, `'$'`) prefixed to every legend value.
      * Defaults to `'₹'`. The symbol is rendered as part of the formatted
@@ -69,6 +77,8 @@ export type SavingsGoalSummaryProps = {
      * computed from `current` / `target` and cannot be replaced.
      */
     titleStyle?: StyleProp<TextStyle>;
+    /** Override styles for the `label` caption text (string labels only). */
+    labelStyle?: StyleProp<TextStyle>;
     /** Override the inner legend container styles. */
     legendStyle?: StyleProp<ViewStyle>;
 };
@@ -91,6 +101,6 @@ export type SavingsGoalSummaryProps = {
  * @component
  * @param {SavingsGoalSummaryProps} props
  */
-declare function SavingsGoalSummary({ currency, current, target, children, modes, style, titleStyle, legendStyle, }: SavingsGoalSummaryProps): import("react/jsx-runtime").JSX.Element;
+declare function SavingsGoalSummary({ label, currency, current, target, children, modes, style, titleStyle, labelStyle, legendStyle, }: SavingsGoalSummaryProps): import("react/jsx-runtime").JSX.Element;
 export default SavingsGoalSummary;
 //# sourceMappingURL=SavingsGoalSummary.d.ts.map

package/lib/typescript/src/components/ScrollArea/ScrollArea.d.ts

@@ -0,0 +1,77 @@
+import React from 'react';
+import { ScrollView, type ScrollViewProps, type StyleProp, type ViewStyle } from 'react-native';
+import type { Modes } from '../../design-tokens';
+/**
+ * Axis (or axes) along which the content can be scrolled.
+ *
+ * - `vertical` (default) — content taller than the viewport scrolls up/down.
+ * - `horizontal` — content wider than the viewport scrolls left/right.
+ * - `both` — content larger on either axis scrolls in both directions
+ *   (implemented as a horizontal `ScrollView` nested in a vertical one).
+ */
+export type ScrollDirection = 'vertical' | 'horizontal' | 'both';
+export interface ScrollAreaProps extends Omit<ScrollViewProps, 'horizontal' | 'contentContainerStyle' | 'children'> {
+    /** Content that may be larger than the viewport. */
+    children?: React.ReactNode;
+    /**
+     * Scroll axis. Defaults to `vertical`.
+     * @default 'vertical'
+     */
+    direction?: ScrollDirection;
+    /**
+     * Whether to show the native scroll indicator (scrollbar). Mirrors the Figma
+     * design, which has no visible scrollbar, so this defaults to `false`.
+     * @default false
+     */
+    showScrollIndicator?: boolean;
+    /**
+     * Padding applied to all sides of the scrollable content. Individual sides
+     * (`paddingHorizontal`, `paddingTop`, …) take precedence when provided.
+     * @default 0
+     */
+    padding?: number;
+    /** Left + right padding of the scrollable content. */
+    paddingHorizontal?: number;
+    /** Top + bottom padding of the scrollable content. */
+    paddingVertical?: number;
+    /** Top padding of the scrollable content. */
+    paddingTop?: number;
+    /** Right padding of the scrollable content. */
+    paddingRight?: number;
+    /** Bottom padding of the scrollable content. */
+    paddingBottom?: number;
+    /** Left padding of the scrollable content. */
+    paddingLeft?: number;
+    /**
+     * Style for the viewport (the visible, clipping window). Constrain the
+     * scroll area's size here, e.g. `{ height: 240 }` or `{ flex: 1 }`. The
+     * component intentionally has no background of its own.
+     */
+    style?: StyleProp<ViewStyle>;
+    /** Style for the scrollable content wrapper (sits inside the viewport). */
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    /** Modes object for design-token resolution, cascaded to all children. */
+    modes?: Modes;
+}
+/**
+ * ScrollArea — a transparent, size-constrained viewport that makes content
+ * larger than itself smoothly scrollable (Figma node 6319:46886).
+ *
+ * It has no background of its own; constrain its size through `style`
+ * (`height`, `maxHeight`, or `flex`) and drop any over-sized content inside.
+ *
+ * @example
+ * // Vertical (default): a tall column inside a fixed-height window.
+ * <ScrollArea style={{ height: 240 }}>
+ *   <LongContent />
+ * </ScrollArea>
+ *
+ * @example
+ * // Horizontal: a wide row of cards inside a full-width window.
+ * <ScrollArea direction="horizontal">
+ *   <Card /> <Card /> <Card />
+ * </ScrollArea>
+ */
+export declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<ScrollView>>;
+export default ScrollArea;
+//# sourceMappingURL=ScrollArea.d.ts.map

package/lib/typescript/src/components/Section/Section.d.ts

@@ -18,8 +18,14 @@ type SectionProps = {
      * Web-specific accessibility props (only used on web platform)
      */
     webAccessibilityProps?: WebAccessibilityProps;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 } & React.ComponentProps<typeof View>;
-declare function Section({ title, supportText, showSupportText, slot, slotDirection, modes, onPress, style, accessibilityLabel: _accessibilityLabel, accessibilityHint, webAccessibilityProps, ...rest }: SectionProps): import("react/jsx-runtime").JSX.Element;
+declare function Section({ title, supportText, showSupportText, slot, slotDirection, modes, onPress, style, accessibilityLabel: _accessibilityLabel, accessibilityHint, webAccessibilityProps, disableTruncation, ...rest }: SectionProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Section {
     var Bento: typeof SectionBento;
 }

package/lib/typescript/src/components/Slider/Slider.d.ts

@@ -78,6 +78,12 @@ export interface SliderProps {
     style?: StyleProp<ViewStyle>;
     /** Accessibility label for screen readers. */
     accessibilityLabel?: string;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 }
 /**
  * Slider — Figma node 5373:446 ("Slider").

package/lib/typescript/src/components/Stack/Stack.d.ts

@@ -0,0 +1,81 @@
+import React from 'react';
+import { type StyleProp, type ViewProps, type ViewStyle } from 'react-native';
+import type { Modes } from '../../design-tokens';
+export type StackLayoutDirection = 'vertical' | 'horizontal';
+export type StackProps = ViewProps & {
+    /**
+     * Content laid out inside the stack. `modes` are cascaded to every child via
+     * {@link cloneChildrenWithModes}.
+     */
+    children?: React.ReactNode;
+    /**
+     * Main-axis direction for stack children. Matches the Figma Slot variant:
+     * - `vertical` (default): stacks children in a column
+     * - `horizontal`: arranges children in a row
+     */
+    layoutDirection?: StackLayoutDirection;
+    /**
+     * Alignment along the cross axis.
+     * Defaults to `stretch` for vertical and `flex-start` for horizontal.
+     */
+    alignCrossAxis?: ViewStyle['alignItems'];
+    /**
+     * Distribution along the main axis (maps to `justifyContent`).
+     */
+    justifyMainAxis?: ViewStyle['justifyContent'];
+    /**
+     * Only meaningful when `layoutDirection` is `horizontal`.
+     *
+     * When true, forces every child to share the height of the tallest child. The
+     * height is enforced by the stack itself (`alignItems: 'stretch'` plus an
+     * injected `alignSelf: 'stretch'` on each child), so children can no longer
+     * opt out via their own `alignSelf`. Children with an explicit `height` keep
+     * that height, since a fixed cross-axis dimension defeats stretch in Yoga.
+     *
+     * Overrides `alignCrossAxis` when it applies.
+     */
+    equalHeight?: boolean;
+    /**
+     * Only meaningful when `layoutDirection` is `vertical`.
+     *
+     * When true, forces every child to fill the full width of the stack. The width
+     * is enforced by the stack itself (`alignItems: 'stretch'` plus an injected
+     * `alignSelf: 'stretch'` on each child), so children can no longer opt out via
+     * their own `alignSelf`. Children with an explicit `width` keep that width,
+     * since a fixed cross-axis dimension defeats stretch in Yoga.
+     *
+     * Overrides `alignCrossAxis` when it applies.
+     */
+    fillWidth?: boolean;
+    /**
+     * Mode configuration passed to the token resolver and cascaded to children.
+     */
+    modes?: Modes;
+    style?: StyleProp<ViewStyle>;
+};
+/**
+ * Stack — a token-driven layout container for grouped content.
+ *
+ * Use `Stack` instead of a raw `View` when you need a vertical or horizontal
+ * stack with design-token gap spacing and automatic `modes` propagation to
+ * children. Typical usage is nesting a column of actions inside a
+ * direction-locked parent such as `ActionFooter`:
+ *
+ * @example
+ * ```tsx
+ * <ActionFooter modes={modes}>
+ *   <Stack layoutDirection="vertical" modes={modes}>
+ *     <Button label="Continue" modes={primaryModes} />
+ *     <Disclaimer disclaimer="Terms apply." modes={modes} />
+ *   </Stack>
+ * </ActionFooter>
+ * ```
+ *
+ * @remarks
+ * Previously named `Slot`. The `Slot` export is preserved as a deprecated alias
+ * for backward compatibility.
+ */
+declare function Stack({ children, layoutDirection, alignCrossAxis, justifyMainAxis, equalHeight, fillWidth, modes: propModes, style, ...rest }: StackProps): import("react/jsx-runtime").JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof Stack>;
+export default _default;
+//# sourceMappingURL=Stack.d.ts.map

package/lib/typescript/src/components/SummaryTile/SummaryTile.d.ts

@@ -45,6 +45,12 @@ export type SummaryTileProps = {
     descriptionStyle?: StyleProp<TextStyle>;
     /** Accessibility label override (defaults to `title`). */
     accessibilityLabel?: string;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 };
 /**
  * SummaryTile composes a title (with an inline `StrengthIndicator`), a
@@ -56,6 +62,6 @@ export type SummaryTileProps = {
  * @component
  * @param {SummaryTileProps} props
  */
-declare function SummaryTile({ title, description, confidence, chevron, children, onPress, modes, style, titleStyle, descriptionStyle, accessibilityLabel, }: SummaryTileProps): import("react/jsx-runtime").JSX.Element;
+declare function SummaryTile({ title, description, confidence, chevron, children, onPress, modes, style, titleStyle, descriptionStyle, accessibilityLabel, disableTruncation, }: SummaryTileProps): import("react/jsx-runtime").JSX.Element;
 export default SummaryTile;
 //# sourceMappingURL=SummaryTile.d.ts.map

package/lib/typescript/src/components/Table/Table.d.ts

@@ -0,0 +1,139 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { Modes } from '../../design-tokens';
+export type TableCellAlign = 'left' | 'center' | 'right';
+export type TableCellProps = {
+    children?: React.ReactNode;
+    /** Horizontal alignment of the cell content. @default 'left' */
+    align?: TableCellAlign;
+    /** Fixed cell width. Omit to let the cell flex. */
+    width?: number;
+    /** Flex-grow weight when `width` is not set. @default 1 */
+    flex?: number;
+    /** Drop the right divider (used for the last column). @default false */
+    isLastColumn?: boolean;
+    /** Drop the bottom divider (used for the last row). @default false */
+    isLastRow?: boolean;
+    modes?: Modes;
+    style?: StyleProp<ViewStyle>;
+};
+/**
+ * A single body cell. White background with a bottom + right divider, matching
+ * the Figma `table-cell` sub-component. String/number children are rendered
+ * with the token label style; any element is rendered as-is.
+ */
+declare function TableCell({ children, align, width, flex, isLastColumn, isLastRow, modes, style, }: TableCellProps): import("react/jsx-runtime").JSX.Element;
+export type TableHeaderCellProps = {
+    children?: React.ReactNode;
+    /** Horizontal alignment of the header content. @default 'left' */
+    align?: TableCellAlign;
+    /** Fixed cell width. Omit to let the cell flex. */
+    width?: number;
+    /** Flex-grow weight when `width` is not set. @default 1 */
+    flex?: number;
+    modes?: Modes;
+    style?: StyleProp<ViewStyle>;
+};
+/**
+ * A single header cell. Muted background with the bold token label style,
+ * matching the Figma `table header wrap` sub-component. Header cells carry no
+ * dividers; the header row draws a single bottom divider beneath them.
+ */
+declare function TableHeaderCell({ children, align, width, flex, modes, style, }: TableHeaderCellProps): import("react/jsx-runtime").JSX.Element;
+export type TableHeaderProps = {
+    children?: React.ReactNode;
+    modes?: Modes;
+    style?: StyleProp<ViewStyle>;
+};
+declare function TableHeader({ children, modes, style }: TableHeaderProps): import("react/jsx-runtime").JSX.Element;
+export type TableRowProps = {
+    children?: React.ReactNode;
+    /** When provided, the whole row becomes pressable. */
+    onPress?: () => void;
+    modes?: Modes;
+    style?: StyleProp<ViewStyle>;
+};
+declare function TableRow({ children, onPress, modes, style }: TableRowProps): import("react/jsx-runtime").JSX.Element;
+export type TableBodyProps = {
+    children?: React.ReactNode;
+    modes?: Modes;
+    style?: StyleProp<ViewStyle>;
+};
+declare function TableBody({ children, modes, style }: TableBodyProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Column definition for the data-driven `Table` API. `T` is the shape of one
+ * row record.
+ */
+export type TableColumn<T> = {
+    /** Stable key; also used to read `row[key]` when no `render` is provided. */
+    key: string;
+    /** Header label. Defaults to `key`. */
+    header?: React.ReactNode;
+    /** Cell + header horizontal alignment. @default 'left' */
+    align?: TableCellAlign;
+    /** Header-only alignment override. Defaults to `align`. */
+    headerAlign?: TableCellAlign;
+    /** Fixed column width. Omit to let the column flex. */
+    width?: number;
+    /** Flex-grow weight when `width` is not set. @default 1 */
+    flex?: number;
+    /** Custom cell renderer. Falls back to `row[key]` as text. */
+    render?: (row: T, rowIndex: number) => React.ReactNode;
+};
+export type TableProps<T = Record<string, unknown>> = {
+    /** Column definitions for the data-driven API. */
+    columns?: TableColumn<T>[];
+    /** Row records, one per table row. */
+    data?: T[];
+    /**
+     * Composition children (`Table.Header`, `Table.Body`, `Table.Row`,
+     * `Table.Cell`, `Table.HeaderCell`). When provided, `columns`/`data` are
+     * ignored and the children are rendered as-is.
+     */
+    children?: React.ReactNode;
+    /** Show the header row in the data-driven API. @default true */
+    showHeader?: boolean;
+    /** Resolve a stable key per row. Defaults to the row index. */
+    getRowKey?: (row: T, index: number) => React.Key;
+    /** Called when a row is pressed (data-driven API). Makes rows pressable. */
+    onRowPress?: (row: T, index: number) => void;
+    /**
+     * Wrap the table in a horizontal `ScrollView`. Use with fixed-width columns
+     * for wide tables that exceed the viewport on mobile. @default false
+     */
+    scrollable?: boolean;
+    /** Accessibility label for the table container. */
+    accessibilityLabel?: string;
+    /** Design token modes for theming (e.g. `{ "Color Mode": "Light" }`). */
+    modes?: Modes;
+    /** Override the outer container style. */
+    style?: StyleProp<ViewStyle>;
+};
+/**
+ * Table renders structured rows and columns. It supports two complementary
+ * usage styles that share the same token-driven styling:
+ *
+ * 1. **Data-driven** (recommended): pass `columns` + `data`. The header and body
+ *    are built for you, columns stay aligned, and per-column `align`/`width`/
+ *    `flex`/`render` give full control.
+ *
+ * 2. **Composition**: pass `Table.Header` / `Table.Body` / `Table.Row` /
+ *    `Table.Cell` / `Table.HeaderCell` as children for bespoke layouts. These
+ *    sub-components are also exported standalone.
+ *
+ * Implementation of Figma node `5732:3710` (`Table`) with sub-components
+ * `603:23` (`table-cell`) and `603:21` (`table header wrap`).
+ *
+ * @component
+ */
+declare function Table<T = Record<string, unknown>>({ columns, data, children, showHeader, getRowKey, onRowPress, scrollable, accessibilityLabel, modes, style, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace Table {
+    var Header: typeof TableHeader;
+    var HeaderCell: typeof TableHeaderCell;
+    var Body: typeof TableBody;
+    var Row: typeof TableRow;
+    var Cell: typeof TableCell;
+}
+export { TableHeader, TableHeaderCell, TableBody, TableRow, TableCell };
+export default Table;
+//# sourceMappingURL=Table.d.ts.map

package/lib/typescript/src/components/Text/Text.d.ts

@@ -21,6 +21,21 @@ export type TextProps = {
     style?: StyleProp<TextStyle>;
     /** Number of lines to limit the text to. */
     numberOfLines?: number;
+    /**
+     * When `true`, disables text truncation entirely: the trailing ellipsis (`…`)
+     * is never shown and any `numberOfLines` clamp is ignored. The text is also
+     * never shrunk by a tight parent — it keeps its full intrinsic size and
+     * overflows (even breaking the parent layout) rather than clipping into an
+     * ellipsis. It still wraps onto multiple lines.
+     */
+    disableTruncation?: boolean;
+    /**
+     * When `true`, forces the text onto a single line with no wrapping (implies
+     * {@link disableTruncation}). On web the line overflows horizontally —
+     * brutally breaking the parent layout if it has to — instead of wrapping or
+     * truncating.
+     */
+    singleLine?: boolean;
     /**
      * Explicit per-instance loading override. When `true`, this `Text` renders
      * a skeleton placeholder regardless of any surrounding `<SkeletonGroup>`.
@@ -41,6 +56,6 @@ export type TextProps = {
      */
     skeletonLines?: number;
 };
-declare function Text({ text, children, textAlign, modes, style, numberOfLines, loading, skeletonWidth, skeletonLines, }: TextProps): import("react/jsx-runtime").JSX.Element;
+declare function Text({ text, children, textAlign, modes, style, numberOfLines, disableTruncation, singleLine, loading, skeletonWidth, skeletonLines, }: TextProps): import("react/jsx-runtime").JSX.Element;
 export default Text;
 //# sourceMappingURL=Text.d.ts.map

package/lib/typescript/src/components/TextSegment/TextSegment.d.ts

@@ -54,6 +54,21 @@ export type TextSegmentProps = {
     textAlign?: 'Left' | 'Center';
     /** Clamp the paragraph to this many lines (truncates with an ellipsis). Applies to the whole composed line, not per-run. */
     numberOfLines?: number;
+    /**
+     * When `true`, disables truncation entirely: the trailing ellipsis (`…`) is
+     * never shown and the `numberOfLines` clamp is ignored. The paragraph is also
+     * never shrunk by a tight parent — it keeps its full intrinsic size and
+     * overflows (even breaking the parent layout) rather than clipping into an
+     * ellipsis. It still wraps onto multiple lines.
+     */
+    disableTruncation?: boolean;
+    /**
+     * When `true`, forces the whole paragraph onto a single line with no wrapping
+     * (implies {@link disableTruncation}). On web the line overflows horizontally
+     * — brutally breaking the parent layout if it has to — instead of wrapping or
+     * truncating.
+     */
+    singleLine?: boolean;
     /** Mode configuration used for the base style and cascaded to every run/child. */
     modes?: Modes;
     /** Style override applied to the outer paragraph (e.g. width constraints to force wrapping). */
@@ -94,7 +109,7 @@ export type TextSegmentProps = {
  * </TextSegment>
  * ```
  */
-declare function TextSegment({ segments, children, textAlign, numberOfLines, modes, style, }: TextSegmentProps): import("react/jsx-runtime").JSX.Element;
+declare function TextSegment({ segments, children, textAlign, numberOfLines, disableTruncation, singleLine, modes, style, }: TextSegmentProps): import("react/jsx-runtime").JSX.Element;
 declare const _default: React.MemoExoticComponent<typeof TextSegment>;
 export default _default;
 //# sourceMappingURL=TextSegment.d.ts.map

package/lib/typescript/src/components/ThreadHero/ThreadHero.d.ts

@@ -14,9 +14,15 @@ export type ThreadHeroProps = {
     modes?: Modes;
     /** Optional container style */
     style?: ViewStyle;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 };
 /**
  * ThreadHero component displaying a central identity with avatar, title, subtitle, and caption.
  */
-export default function ThreadHero({ title, subtitle, caption, renderAvatar, modes, style, }: ThreadHeroProps): import("react/jsx-runtime").JSX.Element;
+export default function ThreadHero({ title, subtitle, caption, renderAvatar, modes, style, disableTruncation, }: ThreadHeroProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=ThreadHero.d.ts.map

package/lib/typescript/src/components/Title/Title.d.ts

@@ -13,9 +13,25 @@ export type TitleProps = {
     /** Optional style overrides for the subtitle text. */
     subtitleStyle?: StyleProp<TextStyle>;
     numberOfLines?: number;
+    /**
+     * When `true`, disables truncation for both the title and subtitle: the
+     * trailing ellipsis (`…`) is never shown and the `numberOfLines` clamp is
+     * ignored. The text is also never shrunk by a tight parent — it keeps its
+     * full intrinsic size and overflows (even breaking the parent layout) rather
+     * than ever clipping into an ellipsis. The text still wraps onto multiple
+     * lines.
+     */
+    disableTruncation?: boolean;
+    /**
+     * When `true`, forces both the title and subtitle onto a single line with no
+     * wrapping (implies {@link disableTruncation}). On web the line overflows
+     * horizontally — brutally breaking the parent layout if it has to — instead
+     * of wrapping or truncating.
+     */
+    singleLine?: boolean;
     accessibilityLabel?: string;
     accessibilityHint?: string;
 } & React.ComponentProps<typeof View>;
-declare function Title({ title, subtitle, textAlign, modes: propModes, style, textStyle, subtitleStyle, numberOfLines, accessibilityLabel, accessibilityHint, ...rest }: TitleProps): import("react/jsx-runtime").JSX.Element;
+declare function Title({ title, subtitle, textAlign, modes: propModes, style, textStyle, subtitleStyle, numberOfLines, disableTruncation, singleLine, accessibilityLabel, accessibilityHint, ...rest }: TitleProps): import("react/jsx-runtime").JSX.Element;
 export default Title;
 //# sourceMappingURL=Title.d.ts.map

package/lib/typescript/src/components/Toast/Toast.d.ts

@@ -9,7 +9,13 @@ export interface ToastProps {
     modes?: Modes | undefined;
     placement?: ToastPlacement | undefined;
     style?: StyleProp<ViewStyle> | undefined;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 }
-declare function Toast({ id, title, timeout, onClose, modes, placement, style, }: ToastProps): import("react/jsx-runtime").JSX.Element;
+declare function Toast({ id, title, timeout, onClose, modes, placement, style, disableTruncation, }: ToastProps): import("react/jsx-runtime").JSX.Element;
 export default Toast;
 //# sourceMappingURL=Toast.d.ts.map

package/lib/typescript/src/components/TransactionBubble/TransactionBubble.d.ts

@@ -17,6 +17,12 @@ export type TransactionBubbleProps = {
     accessibilityLabel?: string;
     accessibilityHint?: string;
     webAccessibilityProps?: WebAccessibilityProps;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 } & Omit<PressableProps, 'style' | 'children' | 'onPress'>;
 /**
  * TransactionBubble — Figma node 1517:1155.
@@ -35,6 +41,6 @@ export type TransactionBubbleProps = {
  * statusWrap: TransactionStatus + NavArrow, horizontal row with `transactionBubble/statusWrap/gap`.
  * Container gap between sections: `transactionBubble/gap`.
  */
-declare function TransactionBubble({ description, value, currency, status, date, statusSlot, children, modes, onPress, style, accessibilityLabel, accessibilityHint, webAccessibilityProps, ...rest }: TransactionBubbleProps): import("react/jsx-runtime").JSX.Element;
+declare function TransactionBubble({ description, value, currency, status, date, statusSlot, children, modes, onPress, style, accessibilityLabel, accessibilityHint, webAccessibilityProps, disableTruncation, ...rest }: TransactionBubbleProps): import("react/jsx-runtime").JSX.Element;
 export default TransactionBubble;
 //# sourceMappingURL=TransactionBubble.d.ts.map

package/lib/typescript/src/components/TransactionStatus/TransactionStatus.d.ts

@@ -9,9 +9,15 @@ export type TransactionStatusProps = {
     modes?: Modes;
     /** Optional container style */
     style?: ViewStyle;
+    /**
+     * When `true`, disables text truncation: the trailing ellipsis (`…`) is never
+     * shown and any `numberOfLines` clamp is ignored, so the text wraps to as many
+     * lines as it needs even when horizontal space is tight.
+     */
+    disableTruncation?: boolean;
 };
 /**
  * TransactionStatus component displaying status icon, label, and date.
  */
-export default function TransactionStatus({ status, date, modes, style, }: TransactionStatusProps): import("react/jsx-runtime").JSX.Element;
+export default function TransactionStatus({ status, date, modes, style, disableTruncation, }: TransactionStatusProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=TransactionStatus.d.ts.map