themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/base/forms-numeric/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Numeric and unit-bearing form controls.
+ *
+ * These are the fields whose value is a number plus a unit, currency, or
+ * rounding policy rather than free text. They are presentational and
+ * framework-free — pass value/onChange directly, and wrap them in `FormField`
+ * or `ControlledFormField` from `themelia-react-ui/base/forms` for the
+ * standard label / hint / error chrome.
+ *
+ * `MoneyInput` is the canonical monetary editor. `CurrencyInput` is the
+ * lower-level split-state control it is built on; reach for it only when the
+ * call site deliberately stores amount and currency in separate channels.
+ */
+export { DecimalInput, type DecimalInputProps } from './decimal-input';
+export { PercentageInput, type PercentageInputProps } from './percentage-input';
+export { CurrencyInput, defaultCurrencyInputStrings, type CurrencyInputProps, type CurrencyInputStrings, type CurrencyOption, } from './currency-input';
+export { MoneyInput, defaultMoneyInputStrings, type MoneyInputProps, type MoneyInputData, type MoneyInputContext, type MoneyInputStrings, } from './money-input';
+export { RoundingModeSelect, type RoundingModeSelectProps } from './rounding-mode-select';
+export { DimensionsInput, type DimensionsInputProps, type DimensionValue, type DimensionObject, type DimensionUnit, } from './dimensions-input';
+export { WeightInput, defaultWeightInputStrings, type WeightInputProps, type WeightInputStrings, type WeightUnit, } from './weight-input';
+export { CoordinatesInput, type CoordinatesInputProps, type CoordinatesValue, type CoordinatesObjectValue, } from './coordinates-input';

package/dist/components/base/forms-numeric/money-input.d.ts

@@ -0,0 +1,67 @@
+import { type ReactNode } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+import { type CurrencyCode } from '../../../lib/ui-provider';
+import { type CurrencyInputProps, type CurrencyOption } from './currency-input';
+import { type MoneyInputStrings } from './money-input.strings';
+export interface MoneyInputContext {
+    /** Original major-unit amount, when available. */
+    amount?: number | string | null;
+    /** Original value currency, when available. */
+    currency?: string | null;
+    /** Optional original/record currency that can trigger a conversion warning. */
+    recordCurrency?: string | null;
+    /** Consumer-formatted original value shown as supporting context. */
+    pair?: {
+        formatted?: string | null;
+    } | null;
+}
+export interface MoneyInputData {
+    /** Parsed major-unit amount. `null` means the field is empty or incomplete; it is never coerced to zero. */
+    amount: number | null;
+    /** Active ISO 4217 currency code. */
+    currency: CurrencyCode;
+}
+export interface MoneyInputProps extends Omit<CurrencyInputProps, 'currency' | 'defaultCurrency' | 'currencies' | 'onCurrencyChange' | 'strings'> {
+    /** Current currency value (ISO 4217 code, e.g. `USD`). */
+    currency?: CurrencyCode;
+    /** Initial currency when uncontrolled. Falls back to UIProvider money config. */
+    defaultCurrency?: CurrencyCode;
+    /** Available currencies. Custom option labels are preserved. */
+    currencies?: Array<CurrencyCode | CurrencyOption>;
+    /** Currency-only callback for existing form integrations. */
+    onCurrencyChange?: (currency: CurrencyCode) => void;
+    /**
+     * Combined amount/currency callback for domain-form state. The amount is
+     * parsed while the raw `value` / `onChange` channel keeps intermediate text
+     * such as `1.` available to the editor.
+     */
+    onChangeData?: (data: MoneyInputData) => void;
+    /** Optional context used for original-value and conversion messaging. */
+    money?: MoneyInputContext | null;
+    /** Optional field label. Omit when an external FormField already owns the chrome. */
+    label?: string;
+    /** Short guidance rendered below the control when no helper text or error is present. */
+    hint?: string;
+    /** Supporting copy rendered below the control. */
+    helperText?: string;
+    /** Validation message. Also marks the amount and currency controls invalid. */
+    error?: string;
+    /** Marks the owned label and native amount input as required. */
+    required?: boolean;
+    /** Existing record currency used to detect a currency migration. */
+    recordCurrency?: CurrencyCode;
+    /** Whether a record-currency mismatch renders the conversion warning. */
+    showMigrationWarning?: boolean;
+    /** Consumer-owned warning content for a record-currency mismatch. */
+    migrationWarningMessage?: ReactNode;
+    /** Whether to render `money.pair.formatted` as original-value context. */
+    showOriginalHint?: boolean;
+    /** String overrides forwarded to the underlying DecimalInput steppers. */
+    controlStrings?: CurrencyInputProps['strings'];
+    /** Class name for the inner amount input. `className` styles the complete MoneyInput surface. */
+    controlClassName?: string;
+    /** Copy overrides for original-value and conversion-warning messages. */
+    strings?: StringsProp<MoneyInputStrings>;
+}
+export declare const MoneyInput: import("react").ForwardRefExoticComponent<Omit<MoneyInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export { defaultMoneyInputStrings, type MoneyInputStrings, } from './money-input.strings';

package/dist/components/base/forms-numeric/money-input.strings.d.ts

@@ -0,0 +1,6 @@
+export interface MoneyInputStrings {
+    originalValue: string;
+    conversionWarning: string;
+}
+export declare const defaultMoneyInputStrings: MoneyInputStrings;
+export declare function interpolateMoneyInputString(template: string, values: Record<string, string>): string;

package/dist/components/base/forms-numeric/percentage-input.d.ts

@@ -0,0 +1,8 @@
+import { type DecimalInputProps } from './decimal-input';
+export type PercentageInputProps = Omit<DecimalInputProps, 'min' | 'max' | 'allowNegative' | 'endAddon'> & {
+    /** Minimum percentage value. Defaults to 0. */
+    min?: number;
+    /** Maximum percentage value. Defaults to 100. */
+    max?: number;
+};
+export declare const PercentageInput: import("react").ForwardRefExoticComponent<Omit<PercentageInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/base/forms-numeric/rounding-mode-select.d.ts

@@ -0,0 +1,12 @@
+import { type SelectProps } from '../choice-inputs';
+type RoundingMode = string;
+export interface RoundingModeSelectProps extends Omit<SelectProps, 'options' | 'value' | 'onValueChange'> {
+    /** Current rounding mode value */
+    value?: RoundingMode;
+    /** Canonical change handler. */
+    onValueChange?: (value: RoundingMode | undefined) => void;
+    /** Custom labels for rounding modes */
+    labels?: Partial<Record<RoundingMode, string>>;
+}
+export declare const RoundingModeSelect: import("react").ForwardRefExoticComponent<RoundingModeSelectProps & import("react").RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/base/forms-numeric/weight-input.d.ts

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import { type StringsProp } from '../../../lib/strings';
+import { type FormControlSize } from '../../../lib/ui-provider';
+export type WeightUnit = 'g' | 'kg' | 'lb' | 'oz';
+export interface WeightInputStrings {
+    /** Above-field label for the unit selector. Empty string hides it. */
+    unitLabel: string;
+    /** Accessible name for the unit selector. */
+    unitAriaLabel: string;
+    /** Placeholder shown in the unit selector. */
+    unitPlaceholder: string;
+}
+export declare const defaultWeightInputStrings: WeightInputStrings;
+export interface WeightInputProps {
+    /** Controlled value */
+    value?: string;
+    /** Default value for uncontrolled mode */
+    defaultValue?: string;
+    /** Current unit */
+    unit?: WeightUnit;
+    /** Default unit for uncontrolled mode */
+    defaultUnit?: WeightUnit;
+    /** Value change handler */
+    onChange?: (e: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    /** Unit change handler */
+    onUnitChange?: (unit: WeightUnit) => void;
+    /** Number of decimal places */
+    decimalPlaces?: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Show unit selector */
+    showUnitSelector?: boolean;
+    /** Disable unit selector */
+    disableUnitSelector?: boolean;
+    /** Override default strings (unit selector label + placeholder). */
+    strings?: StringsProp<WeightInputStrings>;
+    /** Width of unit selector */
+    unitWidth?: string;
+    /** Error state for styling (passed from FormField) */
+    invalid?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Form control size — flows through `useDensityConfig().defaultScale`. */
+    size?: FormControlSize;
+    /** Additional class names */
+    className?: string;
+}
+export declare const WeightInput: React.ForwardRefExoticComponent<WeightInputProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/base/item/index.d.ts

@@ -0,0 +1,2 @@
+export { Item, ItemGroup, ItemSeparator, ItemMedia, ItemContent, ItemTitle, ItemDescription, ItemActions, ItemHeader, ItemFooter, } from './item';
+export type { ItemProps, ItemSharedProps, ItemCompoundMode, ItemConvenienceMode, ItemPadding, ItemDensity, ItemGroupProps, ItemMediaProps, ItemMediaVariant, ItemContentProps, ItemTitleProps, ItemDescriptionProps, ItemActionsProps, ItemHeaderProps, ItemFooterProps, ItemSize, ItemVariant, } from './item.types';

package/dist/components/base/item/item.d.ts

@@ -0,0 +1,12 @@
+import type { ItemActionsProps, ItemContentProps, ItemDescriptionProps, ItemFooterProps, ItemGroupProps, ItemHeaderProps, ItemMediaProps, ItemTitleProps } from './item.types';
+declare const Item: import("react").ForwardRefExoticComponent<(Omit<import("./item.types").ItemSharedProps & import("./item.types").ItemCompoundMode, "ref"> | Omit<import("./item.types").ItemSharedProps & import("./item.types").ItemConvenienceMode, "ref">) & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemGroup: import("react").ForwardRefExoticComponent<Omit<ItemGroupProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemSeparator: import("react").ForwardRefExoticComponent<Omit<import("@base-ui/react").SeparatorProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemMedia: import("react").ForwardRefExoticComponent<Omit<ItemMediaProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemContent: import("react").ForwardRefExoticComponent<Omit<ItemContentProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemActions: import("react").ForwardRefExoticComponent<Omit<ItemActionsProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemHeader: import("react").ForwardRefExoticComponent<Omit<ItemHeaderProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemFooter: import("react").ForwardRefExoticComponent<Omit<ItemFooterProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemTitle: import("react").ForwardRefExoticComponent<Omit<ItemTitleProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+declare const ItemDescription: import("react").ForwardRefExoticComponent<Omit<ItemDescriptionProps, "ref"> & import("react").RefAttributes<HTMLParagraphElement>>;
+export { Item, ItemGroup, ItemSeparator, ItemMedia, ItemContent, ItemTitle, ItemDescription, ItemActions, ItemHeader, ItemFooter, };

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

@@ -0,0 +1,100 @@
+import type { TextGap } from '../structure';
+import type { RowDensity } from '../../../lib/row-recipes';
+/**
+ * Type contracts for the `<Item>` family.
+ *
+ * The base wrapper extends shadcn's primitive props with our provider-driven
+ * defaults (size from `UIProvider.density`) and the canonical title/description
+ * typography mapping. Consumers writing custom partials on top of the wrapper
+ * should import these types instead of reaching into `@/components/ui/item`.
+ */
+import type { ComponentProps, ReactElement, ReactNode } from 'react';
+import type { ItemSize, ItemVariant } from '../../../lib/ui-provider';
+export type { ItemSize, ItemVariant };
+export type ItemMediaVariant = 'default' | 'icon' | 'image' | 'avatar';
+export type ItemPadding = 'none' | 'default';
+export type ItemDensity = RowDensity;
+export interface ItemBaseProps extends Omit<ComponentProps<'div'>, 'children'> {
+    children?: ReactNode;
+}
+export interface ItemSharedProps extends Omit<ItemBaseProps, 'children' | 'title'> {
+    /** Row treatment. Defaults to `UIProvider.item.defaultVariant`. */
+    variant?: ItemVariant;
+    /** Legacy visual size for typography/media. Defaults to `UIProvider.density.defaultScale`. */
+    size?: ItemSize;
+    /** Vertical row rhythm only; preserves size, primary text and inline padding. Defaults to default. */
+    density?: ItemDensity;
+    /** Horizontal row padding. Defaults to `none`. */
+    padding?: ItemPadding;
+    /** Title/supporting-copy rhythm in convenience mode. Defaults to dense. Compound mode uses ItemContent. */
+    textGap?: TextGap;
+    /** Polymorphic render slot — pass `<a href="…" />` to render the row as a link. */
+    render?: ReactElement;
+}
+/**
+ * Compound mode — you assemble the row yourself from `ItemMedia`,
+ * `ItemContent`, `ItemTitle`, `ItemDescription`, `ItemActions`. The slot props
+ * are typed `never` here so the two modes cannot be mixed in one call.
+ */
+export type ItemCompoundMode = {
+    /** The blocks row parts. */
+    children: ReactNode;
+    media?: never;
+    title?: never;
+    description?: never;
+    trailing?: never;
+    actions?: never;
+    mediaVariant?: never;
+    titleBold?: never;
+    descriptionClamp?: never;
+};
+/**
+ * Convenience mode — the row is assembled for you from the slots below. This is
+ * the shorter path for the common identity row; drop to compound mode when you
+ * need markup the slots do not express.
+ */
+export type ItemConvenienceMode = {
+    children?: never;
+    /** Primary line of the row. Required in this mode. */
+    title: ReactNode;
+    /** Secondary line under the title, clamped by `descriptionClamp`. */
+    description?: ReactNode;
+    /** Leading media — an avatar, icon, or thumbnail. */
+    media?: ReactNode;
+    /** Shape and sizing treatment for `media`. Defaults to `default`. */
+    mediaVariant?: ItemMediaVariant;
+    /** Content at the end of the row, before `actions` — a value or badge. */
+    trailing?: ReactNode;
+    /** Controls at the far end of the row. */
+    actions?: ReactNode;
+    /** Enforces the semantic title weight. Defaults to `true`. */
+    titleBold?: boolean;
+    /** Lines the description may wrap to before truncating. Defaults to `2`. */
+    descriptionClamp?: ItemDescriptionProps['clamp'];
+};
+export type ItemProps = ItemSharedProps & (ItemCompoundMode | ItemConvenienceMode);
+export interface ItemMediaProps extends ItemBaseProps {
+    /** Shape and sizing treatment for the media. */
+    variant?: ItemMediaVariant;
+}
+export interface ItemContentProps extends ItemBaseProps {
+    /** Title/supporting-copy rhythm. Defaults to dense at every control size. */
+    textGap?: TextGap;
+}
+export interface ItemActionsProps extends ItemBaseProps {
+}
+export interface ItemHeaderProps extends ItemBaseProps {
+}
+export interface ItemFooterProps extends ItemBaseProps {
+}
+export interface ItemGroupProps extends ItemBaseProps {
+}
+export interface ItemTitleProps extends ItemBaseProps {
+    /** Whether to enforce semantic typography weight. Defaults to `true`. */
+    bold?: boolean;
+}
+export interface ItemDescriptionProps extends Omit<ComponentProps<'p'>, 'children'> {
+    children?: ReactNode;
+    /** Allow longer descriptions to wrap to N lines. Defaults to `2`. */
+    clamp?: 1 | 2 | 3 | 4 | 'none';
+}

package/dist/components/base/media-gallery/index.d.ts

@@ -0,0 +1,2 @@
+/** Ordered media selection and cover-image editing. */
+export { MediaGallery, defaultMediaGalleryStrings, type MediaGalleryProps, type MediaGalleryStrings, } from './media-gallery';

package/dist/components/base/media-gallery/media-gallery.d.ts

@@ -0,0 +1,45 @@
+import { type StringsProp } from '../../../lib/strings';
+export interface MediaGalleryStrings {
+    addInstruction: string;
+    helper: string;
+    dragOver: string;
+    cover: string;
+    removeAria: string;
+    maxReached: string;
+    /** Sort announcements; {name} is the filename and {position} is its one-based position. */
+    pickedUp?: string;
+    movedTo?: string;
+    dropped?: string;
+    cancelled?: string;
+}
+export declare const defaultMediaGalleryStrings: {
+    addInstruction: string;
+    helper: string;
+    dragOver: string;
+    cover: string;
+    removeAria: string;
+    maxReached: string;
+    pickedUp: string;
+    movedTo: string;
+    dropped: string;
+    cancelled: string;
+};
+export interface MediaGalleryProps {
+    /** Selected files. Controlled. */
+    value?: File[];
+    onValueChange?: (files: File[]) => void;
+    /** Accepted MIME types or extensions. */
+    accept?: string;
+    /** Caps how many files may be added. */
+    maxFiles?: number;
+    /** Disables the control and blocks drops. */
+    disabled?: boolean;
+    /** Applies the invalid styling. */
+    invalid?: boolean;
+    className?: string;
+    /** Merged onto each media tile. */
+    tileClassName?: string;
+    /** Overrides the upload, remove, and empty copy. */
+    strings?: StringsProp<MediaGalleryStrings>;
+}
+export declare const MediaGallery: import("react").ForwardRefExoticComponent<MediaGalleryProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/navigation/breadcrumbs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Breadcrumbs — page hierarchy trail. Last item is rendered as the current
+ * page (non-link); preceding items become links when an `href` is provided.
+ * The public scale follows the shared component scale; CSS variables control
+ * display spacing and typography across the library.
+ */
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import { type ComponentScale } from '../../../lib/ui-provider';
+import { type StringsProp } from '../../../lib/strings';
+export interface BreadcrumbItemType {
+    label: ReactNode;
+    href?: string;
+    handle?: string;
+}
+export type BreadcrumbSize = ComponentScale;
+export interface BreadcrumbsStrings {
+    navigationLabel: string;
+}
+export declare const defaultBreadcrumbsStrings: BreadcrumbsStrings;
+type BreadcrumbLinkRenderer = (props: {
+    href?: string;
+    children: ReactNode;
+    className?: string;
+    'aria-label'?: string;
+}) => ReactNode;
+export interface BreadcrumbsProps extends Omit<ComponentPropsWithoutRef<'nav'>, 'children'> {
+    /** Trail entries, root first. */
+    breadcrumbs: BreadcrumbItemType[];
+    /** Typography scale for the trail. */
+    size?: BreadcrumbSize;
+    /** Renders entries carrying an `href` through the consumer's router. */
+    renderLink?: BreadcrumbLinkRenderer;
+    /** Overrides the trail's own copy. */
+    strings?: StringsProp<BreadcrumbsStrings>;
+}
+export declare const Breadcrumbs: import("react").ForwardRefExoticComponent<BreadcrumbsProps & import("react").RefAttributes<HTMLElement>>;
+export {};

package/dist/components/base/navigation/dropdown-menu.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { Menu as MenuPrimitive } from '@base-ui/react/menu';
+import { type CollectionDensity } from '../popover/popover.recipes';
+declare function DropdownMenu({ ...props }: MenuPrimitive.Root.Props): React.JSX.Element;
+declare function DropdownMenuPortal({ container, ...props }: MenuPrimitive.Portal.Props): React.JSX.Element;
+declare function DropdownMenuTrigger({ children, ...props }: MenuPrimitive.Trigger.Props): React.JSX.Element;
+declare function DropdownMenuContent({ positionMethod, align, alignOffset, side, sideOffset, className, density: densityProp, ...props }: MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, 'align' | 'alignOffset' | 'side' | 'sideOffset' | 'positionMethod'> & {
+    /** Vertical row rhythm. Inherits in submenus; defaults to default. */
+    density?: CollectionDensity;
+}): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, children, ...props }: MenuPrimitive.GroupLabel.Props & {
+    /** Surface inset. */
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, children, ...props }: MenuPrimitive.Item.Props & {
+    /** Surface inset. */
+    inset?: boolean;
+    /** Semantic tone. */
+    variant?: 'default' | 'destructive';
+}): React.JSX.Element;
+declare function DropdownMenuLinkItem({ className, inset, variant, children, ...props }: MenuPrimitive.LinkItem.Props & {
+    /** Surface inset. */
+    inset?: boolean;
+    /** Semantic tone. */
+    variant?: 'default' | 'destructive';
+}): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: MenuPrimitive.SubmenuTrigger.Props & {
+    /** Surface inset. */
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: MenuPrimitive.CheckboxItem.Props & {
+    /** Surface inset. */
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props): React.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: MenuPrimitive.RadioItem.Props & {
+    /** Surface inset. */
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: MenuPrimitive.Separator.Props): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, children, ...props }: React.ComponentProps<'span'>): React.JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuLinkItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/components/base/navigation/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Navigation — the generic navigation controls.
+ *
+ * Tabs, breadcrumbs, pagination, dropdown-menu parts, the language switcher,
+ * and the `PageHeading` block: surfaces that move a user between peers or
+ * pages, or that title one, and that position their own known content.
+ *
+ * Navigation regions that frame a page and position content they do not own —
+ * side nav, section nav, category nav, breadcrumb progress — live in
+ * `layout/navigation`. The definition-driven action surfaces `ActionMenu` and
+ * `ActionButtons` live in `base/action-menu`.
+ */
+export { Breadcrumbs, defaultBreadcrumbsStrings, type BreadcrumbItemType, type BreadcrumbsProps, type BreadcrumbsStrings, type BreadcrumbSize, } from './breadcrumbs';
+export * from './dropdown-menu';
+export { LanguageSwitcher, type LanguageSwitcherProps } from './language-switcher';
+export { NavigationTabs, defaultNavigationTabsStrings, type NavigationTabItem, type NavigationTabsProps, type NavigationTabsStrings, type NavigationTabsVariant, } from './navigation-tabs';
+export { Tabs, TabsContent, TabsList, TabsTrigger, type TabsListProps } from './tabs';
+export { defaultTabsScrollStrings, type TabsScrollStrings } from './tab-scroll-viewport';
+export { PageHeading, type PageHeadingProps, type PageHeadingBadge, } from './page-header';
+export { OverflowTabBar, defaultOverflowTabBarStrings, type OverflowTabBarProps, type OverflowTabBarStrings, type OverflowTabItem, } from './overflow-tab-bar';
+export { PaginationPrimitive, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, defaultPaginationStrings, type PaginationContentProps, type PaginationEllipsisProps, type PaginationItemProps, type PaginationLinkProps, type PaginationNextProps, type PaginationPreviousProps, type PaginationProps, type PaginationStrings, } from './pagination';

package/dist/components/base/navigation/language-switcher.d.ts

@@ -0,0 +1,12 @@
+import type { LocaleOption } from '../../../types/locale.types';
+export interface LanguageSwitcherProps {
+    locales: LocaleOption[];
+    onRenderLabel?: (options: LocaleOption) => string;
+    /** Semantic tone. */
+    variant?: 'buttons' | 'inline';
+    onSelect?: (value: string) => void;
+}
+export declare function LanguageSwitcher({ locales, onRenderLabel, variant, onSelect, }: LanguageSwitcherProps): import("react").JSX.Element | null;
+export declare namespace LanguageSwitcher {
+    var displayName: string;
+}

package/dist/components/base/navigation/navigation-tabs.d.ts

@@ -0,0 +1,40 @@
+/**
+ * NavigationTabs — canonical route-tab navigation.
+ *
+ * The default compact treatment works for ordinary application navigation;
+ * `variant="prominent"` provides the stronger filled treatment without
+ * introducing a second component or item vocabulary.
+ */
+import { type ReactNode } from 'react';
+import type { LucideIcon } from 'lucide-react';
+import { type StringsProp } from '../../../lib/strings';
+import { type TabsScrollStrings } from './tab-scroll-viewport';
+export interface NavigationTabItem {
+    title: string;
+    href: string;
+    icon?: LucideIcon | string;
+    badge?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+}
+export interface NavigationTabsStrings {
+    tabsAria: string;
+}
+export declare const defaultNavigationTabsStrings: NavigationTabsStrings;
+export type NavigationTabsVariant = 'default' | 'prominent';
+export interface NavigationTabsProps {
+    /** Tabs to render, in order. */
+    items: readonly NavigationTabItem[];
+    /** Path of the active route, used to mark the current tab. */
+    currentPath?: string;
+    /** Visual treatment of the tab row. */
+    variant?: NavigationTabsVariant;
+    /** Show previous/next controls when route tabs overflow. Defaults to true. */
+    scrollable?: boolean;
+    /** Accessible labels for the previous/next scroll controls. */
+    scrollStrings?: StringsProp<TabsScrollStrings>;
+    /** Overrides the tab row's own copy. */
+    strings?: StringsProp<NavigationTabsStrings>;
+    className?: string;
+}
+export declare const NavigationTabs: import("react").ForwardRefExoticComponent<NavigationTabsProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/navigation/overflow-tab-bar.d.ts

@@ -0,0 +1,43 @@
+/**
+ * OverflowTabBar — horizontal tab strip that gracefully degrades on narrow
+ * containers. Tabs that would overflow are moved into a trailing "More"
+ * dropdown so the strip never wraps. Uses a ResizeObserver to recompute on
+ * container resize; the active tab is always kept visible by being moved
+ * out of the overflow set when needed.
+ *
+ * Use `NavigationTabs` instead when a fixed route set cannot overflow.
+ */
+import { type LucideIcon } from 'lucide-react';
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+export interface OverflowTabBarStrings {
+    more: string;
+    navigationLabel: string;
+}
+export declare const defaultOverflowTabBarStrings: OverflowTabBarStrings;
+export interface OverflowTabItem {
+    /** Stable identity for this entry. */
+    id: string;
+    /** Display label. */
+    label: ReactNode;
+    /** Destination for the entry, when it navigates. */
+    href?: string;
+    /** Leading glyph. */
+    icon?: LucideIcon;
+    /** Chip rendered beside the label. */
+    badge?: ReactNode;
+    onClick?: () => void;
+}
+export interface OverflowTabBarProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children'> {
+    /** Entries to render, in order. */
+    items: OverflowTabItem[];
+    /** Currently active tab id. */
+    value?: string;
+    /** Fired with the id of the newly active tab. */
+    onValueChange?: (id: string) => void;
+    tabClassName?: string;
+    activeTabClassName?: string;
+    /** Overrides this surface's own copy. */
+    strings?: StringsProp<OverflowTabBarStrings>;
+}
+export declare const OverflowTabBar: import("react").ForwardRefExoticComponent<OverflowTabBarProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/navigation/page-header/index.d.ts

@@ -0,0 +1 @@
+export { PageHeading, type PageHeadingProps, type PageHeadingBadge, } from './page-header';

package/dist/components/base/navigation/page-header/page-header.d.ts

@@ -0,0 +1,88 @@
+/**
+ * PageHeading — reusable visual heading block for sections and resources.
+ * Higher-level layout components add routing/back behavior around this base
+ * visual primitive instead of reimplementing title, description, badge, and
+ * action spacing.
+ */
+import type { Key, ReactNode } from 'react';
+import { type HeadingTag } from '../../../typography';
+import { type BadgeTone } from '../../badge';
+import { type TextGap } from '../../structure';
+export interface PageHeadingBadge {
+    label: ReactNode;
+    tone?: BadgeTone;
+    key?: Key;
+}
+/**
+ * Slot map, top to bottom and outside in:
+ *
+ * ```text
+ * breadcrumbs
+ * leading │ eyebrow
+ *         │ beforeTitle
+ *         │ titlePrefix │ title  badges  titleSuffix │ actions
+ *         │             │ description
+ *         │             │ afterDescription
+ * children
+ * ───────────────────────────────────────────  (withSeparator)
+ * ```
+ */
+export interface PageHeadingProps {
+    /** Small label above the title. Plain text is rendered as a `DisplayLabel`. */
+    eyebrow?: ReactNode;
+    /** The page title. Plain text is rendered as a `Heading`; pass an element to own the markup. */
+    title: ReactNode;
+    /** Supporting sentence under the title, capped at `max-w-2xl` and aligned to the title's left edge. */
+    description?: ReactNode;
+    /** Title/description rhythm. Defaults to normal. */
+    textGap?: TextGap;
+    /** Heading level for a plain-text `title`. Default: `'h2'`. Set for correct document outline. */
+    headingTag?: HeadingTag;
+    /** Convenience for a single badge beside the title. Ignored when `badges` is set. */
+    badge?: PageHeadingBadge;
+    /** Badges beside the title, in order. Takes precedence over `badge`. */
+    badges?: PageHeadingBadge[];
+    /** Breadcrumb trail rendered above the header block. */
+    breadcrumbs?: ReactNode;
+    /** Content to the left of the entire header column — an avatar or back button. Top-aligned. */
+    leading?: ReactNode;
+    /** Free slot between the eyebrow and the title row, for a banner or status strip. */
+    beforeTitle?: ReactNode;
+    /**
+     * Content immediately left of the title, vertically centred on the title
+     * line alone. Unlike `leading`, the description aligns to the title's left
+     * edge rather than to this slot, so an icon here never shifts the copy.
+     */
+    titlePrefix?: ReactNode;
+    /** Content after the title and badges, on the same line. */
+    titleSuffix?: ReactNode;
+    /** Content directly beneath the description, sharing its alignment — a metadata line. */
+    afterDescription?: ReactNode;
+    /** Independent actions column beside the copy; follows it on narrow widths. */
+    actions?: ReactNode;
+    /** Content below the whole header block, above the separator. */
+    children?: ReactNode;
+    /** Merged onto the `<header>` root. */
+    className?: string;
+    /** Merged onto the column holding eyebrow, title, and description. */
+    contentClassName?: string;
+    /** Merged onto the eyebrow. Only applies when `eyebrow` is plain text. */
+    eyebrowClassName?: string;
+    /** Merged onto the title. Only applies when `title` is plain text. */
+    titleClassName?: string;
+    /**
+     * Merged onto the title row's grid. A `gap-space-md` here sets the
+     * `titlePrefix`-to-title rhythm without also opening the gap under the title.
+     */
+    titleRowClassName?: string;
+    /** Merged onto the description. Only applies when `description` is plain text. */
+    descriptionClassName?: string;
+    /** Merged onto the actions cluster. */
+    actionsClassName?: string;
+    /** Draws the rule beneath the header. Default: `true`. */
+    withSeparator?: boolean;
+}
+export declare function PageHeading({ eyebrow, title, description, textGap, headingTag, badge, badges, breadcrumbs, leading, beforeTitle, titlePrefix, titleSuffix, afterDescription, actions, children, className, contentClassName, eyebrowClassName, titleClassName, titleRowClassName, descriptionClassName, actionsClassName, withSeparator, }: PageHeadingProps): import("react").JSX.Element;
+export declare namespace PageHeading {
+    var displayName: string;
+}