@conuti-das/prince-ui 0.9.3

package/dist/index.d.ts

@@ -0,0 +1,1466 @@
+import * as react from 'react';
+import { SVGProps, ReactNode, CSSProperties, MouseEvent, HTMLAttributes, ElementType } from 'react';
+import { ButtonProps as ButtonProps$1, CheckboxProps as CheckboxProps$1, SearchFieldProps as SearchFieldProps$1, SelectProps as SelectProps$1, ListBoxItemProps, SwitchProps as SwitchProps$1, TextFieldProps as TextFieldProps$1, PopoverProps, MenuItemProps, ToggleButtonProps, ToggleButtonGroupProps, TabProps, TabListProps, TabPanelProps, TabsProps as TabsProps$1, CheckboxGroupProps as CheckboxGroupProps$1, RadioProps as RadioProps$1, RadioGroupProps as RadioGroupProps$1, NumberFieldProps as NumberFieldProps$1, SliderProps as SliderProps$1, ComboBoxProps as ComboBoxProps$1, FieldErrorProps as FieldErrorProps$1, FormProps as FormProps$1, GridListProps as GridListProps$1, GridListItemProps as GridListItemProps$1, ListBoxProps as ListBoxProps$1, TagProps as TagProps$1, TagGroupProps as TagGroupProps$1, TagListProps, BreadcrumbProps as BreadcrumbProps$1, BreadcrumbsProps as BreadcrumbsProps$1, LinkProps as LinkProps$1, DisclosureProps as DisclosureProps$1, DisclosureGroupProps as DisclosureGroupProps$1, TreeProps as TreeProps$1, TreeItemProps as TreeItemProps$1, CellProps as CellProps$1, ColumnProps as ColumnProps$1, RowProps as RowProps$1, TableProps as TableProps$1, TableBodyProps as TableBodyProps$1, TableHeaderProps as TableHeaderProps$1, DateValue, DateFieldProps as DateFieldProps$1, TimeValue, TimeFieldProps as TimeFieldProps$1, CalendarProps as CalendarProps$1, RangeCalendarProps as RangeCalendarProps$1, DatePickerProps as DatePickerProps$1, DateRangePickerProps as DateRangePickerProps$1, ColorFieldProps as ColorFieldProps$1, ColorSwatchProps as ColorSwatchProps$1, ColorSwatchPickerProps as ColorSwatchPickerProps$1, ColorSwatchPickerItemProps as ColorSwatchPickerItemProps$1, ColorAreaProps as ColorAreaProps$1, ColorPickerProps as ColorPickerProps$1, ColorSliderProps as ColorSliderProps$1, ColorWheelProps as ColorWheelProps$1, GroupProps as GroupProps$1, MeterProps as MeterProps$1, ProgressBarProps as ProgressBarProps$1, SeparatorProps as SeparatorProps$1, ToastRegionProps as ToastRegionProps$1, UNSTABLE_ToastQueue, DropZoneProps as DropZoneProps$1, FileTriggerProps as FileTriggerProps$1 } from 'react-aria-components';
+export { DialogTrigger, parseColor } from 'react-aria-components';
+import { RowData, TableOptions, Table as Table$1 } from '@tanstack/react-table';
+
+/** Klassen-Helper: filtert Falsy-Werte und joint mit Space. */
+declare function cx(...parts: Array<string | false | null | undefined>): string;
+
+/**
+ * Monochrome Linien-Icons (SVG, `currentColor`) — bewusst KEINE Emoji.
+ *
+ * Stil: 24×24-Grid, `fill: none`, `stroke: currentColor`, 2px, runde Enden
+ * (lucide-kompatible Optik). Die Icons erben die Textfarbe und sind damit
+ * theme-fähig (Light/Dark/CU). Kein externer Dependency.
+ *
+ * Wer mehr Icons braucht, kann jedes monochrome `currentColor`-SVG (z. B.
+ * `lucide-react`) direkt in die `icon`/`leading`-Slots der Komponenten geben.
+ */
+type IconName = "heart" | "flame" | "moon" | "chart" | "settings" | "menu" | "pin" | "pin-off" | "user" | "building" | "search" | "plus" | "bolt" | "alert" | "inbox" | "compass" | "mail" | "bell" | "grid" | "more" | "maximize" | "check" | "x" | "chevron-right" | "chevron-down" | "chevron-up" | "phone" | "clock" | "link" | "arrow-down-right" | "arrow-up-right" | "droplet" | "file-text";
+interface IconProps extends Omit<SVGProps<SVGSVGElement>, "name"> {
+    /** Name des monochromen Icons. */
+    name: IconName;
+    /** Kantenlänge in px (Default 20). */
+    size?: number | string;
+    /** Wenn gesetzt: zugängliches Label (sonst `aria-hidden`, rein dekorativ). */
+    title?: string;
+}
+/** Monochromes Linien-Icon (erbt `currentColor`). */
+declare function Icon({ name, size, title, ...rest }: IconProps): react.JSX.Element;
+
+interface ButtonProps extends Omit<ButtonProps$1, "className"> {
+    /** Prince-Varianten: gefüllt (Akzent), getönt (soft) oder schlicht. */
+    variant?: "filled" | "tinted" | "plain";
+    className?: string;
+}
+declare function Button({ variant, className, ...props }: ButtonProps): react.JSX.Element;
+interface TextFieldProps extends Omit<TextFieldProps$1, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    className?: string;
+}
+declare function TextField({ label, description, errorMessage, placeholder, className, ...props }: TextFieldProps): react.JSX.Element;
+interface SearchFieldProps extends Omit<SearchFieldProps$1, "className"> {
+    label?: ReactNode;
+    placeholder?: string;
+    className?: string;
+}
+declare function SearchField({ label, placeholder, className, ...props }: SearchFieldProps): react.JSX.Element;
+interface CheckboxProps extends Omit<CheckboxProps$1, "className"> {
+    children?: ReactNode;
+    className?: string;
+}
+declare function Checkbox({ children, className, ...props }: CheckboxProps): react.JSX.Element;
+interface SwitchProps extends Omit<SwitchProps$1, "className"> {
+    children?: ReactNode;
+    className?: string;
+}
+declare function Switch({ children, className, ...props }: SwitchProps): react.JSX.Element;
+interface SelectProps<T extends object> extends Omit<SelectProps$1<T>, "className" | "children"> {
+    label?: ReactNode;
+    placeholder?: string;
+    children: ReactNode | ((item: T) => ReactNode);
+    className?: string;
+}
+declare function Select<T extends object>({ label, placeholder, children, className, ...props }: SelectProps<T>): react.JSX.Element;
+interface SelectItemProps extends Omit<ListBoxItemProps, "className"> {
+    className?: string;
+}
+declare function SelectItem({ className, ...props }: SelectItemProps): react.JSX.Element;
+
+interface ModalProps {
+    isOpen?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+    /** Titel als Überschrift mit slot="title" (für aria-labelledby). */
+    title?: ReactNode;
+    children?: ReactNode;
+    /** Klick auf Scrim schließt (Default true). */
+    isDismissable?: boolean;
+    /** „Liquid Glass"-Optik (transluzent + Blur) statt opaker Fläche. */
+    glass?: boolean;
+    className?: string;
+}
+declare function Modal({ title, children, className, isDismissable, glass, ...props }: ModalProps): react.JSX.Element;
+
+interface MenuProps {
+    /** Trigger-Element (z. B. <Button>). */
+    trigger: ReactNode;
+    children: ReactNode;
+    /** „Liquid Glass"-Optik (transluzent + Blur) statt opaker Fläche. */
+    glass?: boolean;
+    className?: string;
+}
+declare function Menu({ trigger, children, glass, className }: MenuProps): react.JSX.Element;
+interface MenuItemPropsExt extends Omit<MenuItemProps, "className"> {
+    className?: string;
+}
+declare function MenuItem({ className, ...props }: MenuItemPropsExt): react.JSX.Element;
+interface AplPopoverProps extends Omit<PopoverProps, "className"> {
+    /** „Liquid Glass"-Optik (transluzent + Blur) statt opaker Fläche. */
+    glass?: boolean;
+    className?: string;
+}
+declare function Popover({ glass, className, children, ...props }: AplPopoverProps): react.JSX.Element;
+interface TooltipProps {
+    /** Element, das den Tooltip auslöst. */
+    trigger: ReactNode;
+    children: ReactNode;
+    delay?: number;
+    className?: string;
+}
+declare function Tooltip({ trigger, children, delay, className }: TooltipProps): react.JSX.Element;
+
+interface SegmentedControlProps extends Omit<ToggleButtonGroupProps, "className" | "selectionMode"> {
+    className?: string;
+}
+declare function SegmentedControl({ className, disallowEmptySelection, ...props }: SegmentedControlProps): react.JSX.Element;
+interface SegmentProps extends Omit<ToggleButtonProps, "className"> {
+    className?: string;
+}
+declare function Segment({ className, ...props }: SegmentProps): react.JSX.Element;
+interface TabsProps extends Omit<TabsProps$1, "className"> {
+    className?: string;
+}
+declare function Tabs({ className, ...props }: TabsProps): react.JSX.Element;
+declare function TabBar({ className, ...props }: Omit<TabListProps<object>, "className"> & {
+    className?: string;
+}): react.JSX.Element;
+declare function Tab({ className, ...props }: Omit<TabProps, "className"> & {
+    className?: string;
+}): react.JSX.Element;
+declare function TabPanel({ className, ...props }: Omit<TabPanelProps, "className"> & {
+    className?: string;
+    children?: ReactNode;
+}): react.JSX.Element;
+
+interface CardProps {
+    /** Optionaler Titel oben links (alternativ via `header` voll überschreibbar). */
+    title?: ReactNode;
+    /** Freier Header-Slot rechts (z. B. Aktionen) — neben dem Titel. */
+    header?: ReactNode;
+    /** Innenabstand-Variante. */
+    padding?: "none" | "compact" | "regular" | "spacious";
+    /** Glas-Optik: halbtransparenter Hintergrund + Blur (Light & Dark). */
+    translucent?: boolean;
+    /** Macht die Karte klickbar (react-aria Button) mit Hover-Lift — wie KpiCard. */
+    onPress?: () => void;
+    /** Inline-Styles (z. B. App-lokale Maße/Status-Border) auf das Card-Element. */
+    style?: CSSProperties;
+    children?: ReactNode;
+    className?: string;
+}
+declare function Card({ title, header, padding, translucent, onPress, style, children, className, }: CardProps): react.JSX.Element;
+type Trend$1 = "up" | "down" | "flat";
+/** Färbung des KPI-Werts (Drill-down-Semantik). */
+type KpiTone = "positive" | "critical" | "negative";
+interface KpiCardProps {
+    label: ReactNode;
+    value: ReactNode;
+    /** Delta-Text, z. B. "+12 %". */
+    delta?: ReactNode;
+    /** Richtung der Färbung. Wird `delta` ohne `trend` gesetzt, bleibt es neutral. */
+    trend?: Trend$1;
+    /** Färbt den Wert semantisch (grün/orange/rot). */
+    tone?: KpiTone;
+    /** Macht die Kachel klickbar (react-aria Button) mit Hover-Lift. */
+    onPress?: () => void;
+    /** Akzent-„Hero"-Kachel: Vollflächen-Akzent mit dunkler Schrift. */
+    accent?: boolean;
+    /** Optionales Leading-Icon (z. B. SVG/Emoji). */
+    icon?: ReactNode;
+    className?: string;
+}
+declare function KpiCard({ label, value, delta, trend, tone, onPress, accent, icon, className, }: KpiCardProps): react.JSX.Element;
+type BadgeTone = "neutral" | "green" | "red" | "orange" | "blue" | "teal" | "gray";
+interface BadgeProps {
+    tone?: BadgeTone;
+    /** Soft = getönt (Default), solid = vollflächig gefüllt. */
+    variant?: "soft" | "solid";
+    /** Optionales Leading-Icon (SVG/Emoji/ReactNode), links vom Text. */
+    icon?: ReactNode;
+    /** Beliebige Markenfarbe (überschreibt `tone`). Z. B. Team-Farbe. */
+    color?: string;
+    /** Textfarbe bei `color` (Default: Weiß für solid, `color` selbst für soft). */
+    textColor?: string;
+    /** Escape-Hatch: Inline-Styles (z. B. fixe Größe/Radius/Font für Tabellen-Chips). */
+    style?: CSSProperties;
+    children?: ReactNode;
+    className?: string;
+}
+declare function Badge({ tone, variant, icon, color, textColor, style, children, className, }: BadgeProps): react.JSX.Element;
+interface AmountProps {
+    /**
+     * Zahl → wird i18n-formatiert. Bereits formatierter String → wird unverändert
+     * angezeigt (String-Modus; `currency`/`locale`/`fractionDigits` werden ignoriert).
+     */
+    value: number | string;
+    /** ISO-Währungscode, z. B. "EUR". Ohne → reine Zahl. (Nur Zahl-Modus.) */
+    currency?: string;
+    /** BCP-47-Locale für Formatierung (Default "de-DE"). (Nur Zahl-Modus.) */
+    locale?: string;
+    /** Min/Max Nachkommastellen. (Nur Zahl-Modus.) */
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    /** Negativ rot / positiv grün einfärben. */
+    colored?: boolean;
+    /** Immer Vorzeichen anzeigen (auch +). (Nur Zahl-Modus.) */
+    signed?: boolean;
+    /**
+     * Optische Abschwächung der Nachkommastellen (Tail leiser/kleiner).
+     * Erkennt das Dezimaltrennzeichen der Ausgabe und dämpft alles dahinter.
+     */
+    dimDecimals?: boolean;
+    className?: string;
+}
+declare function Amount({ value, currency, locale, minimumFractionDigits, maximumFractionDigits, colored, signed, dimDecimals, className, }: AmountProps): react.JSX.Element;
+interface ListProps {
+    children?: ReactNode;
+    /** Header-Beschriftung über der Liste (macOS-Gruppentitel). */
+    label?: ReactNode;
+    /** Eingerückte Trennlinien (wie iOS-Listen). */
+    inset?: boolean;
+    className?: string;
+}
+declare function List({ children, label, inset, className }: ListProps): react.JSX.Element;
+interface ListRowProps {
+    /** Linkes Element (Icon/Avatar). */
+    leading?: ReactNode;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    /** Rechtes Element (Wert, Badge, Chevron). */
+    trailing?: ReactNode;
+    /** Macht die Zeile pressbar (react-aria Button). */
+    onPress?: () => void;
+    /** Aktiver/ausgewählter Zustand. */
+    isActive?: boolean;
+    isDisabled?: boolean;
+    className?: string;
+}
+declare function ListRow({ leading, title, subtitle, trailing, onPress, isActive, isDisabled, className, }: ListRowProps): react.JSX.Element;
+interface SidebarItem {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Optionales Badge/Counter rechts. */
+    trailing?: ReactNode;
+}
+interface SidebarGroup {
+    /** Gruppentitel (optional). */
+    label?: ReactNode;
+    items: SidebarItem[];
+    /** Macht die Gruppe auf-/zuklappbar (Chevron, klickbarer Titel). Braucht `label`. */
+    collapsible?: boolean;
+    /** Startzustand zugeklappt (nur bei `collapsible`). */
+    defaultCollapsed?: boolean;
+}
+interface SidebarProps {
+    groups: SidebarGroup[];
+    /** Aktive Item-ID. */
+    selectedKey?: string;
+    onSelect?: (id: string) => void;
+    /** Kopfbereich (z. B. App-Titel/Logo). */
+    header?: ReactNode;
+    /** Fußbereich (z. B. Account). */
+    footer?: ReactNode;
+    /** „Liquid Glass"-Optik (transluzent + Blur). Nur über Content sinnvoll. */
+    glass?: boolean;
+    className?: string;
+}
+declare function Sidebar({ groups, selectedKey, onSelect, header, footer, glass, className, }: SidebarProps): react.JSX.Element;
+interface ToolbarProps {
+    title?: ReactNode;
+    /** Untertitel unter dem Titel. */
+    subtitle?: ReactNode;
+    /** Linker Slot (z. B. Zurück-Button) vor dem Titel. */
+    leading?: ReactNode;
+    /** Aktionen rechts. */
+    actions?: ReactNode;
+    /** „Liquid Glass"-Optik (transluzent + Blur). Nur über Content sinnvoll. */
+    glass?: boolean;
+    className?: string;
+}
+declare function Toolbar({ title, subtitle, leading, actions, glass, className }: ToolbarProps): react.JSX.Element;
+interface EmptyStateProps {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    /** Aktions-Slot (z. B. <Button>). */
+    action?: ReactNode;
+    className?: string;
+}
+declare function EmptyState({ icon, title, description, action, className }: EmptyStateProps): react.JSX.Element;
+type NoticeTone = "info" | "positive" | "critical" | "negative";
+interface NoticeProps {
+    tone?: NoticeTone;
+    title?: ReactNode;
+    /** Optionales Leading-Icon (überschreibt Default-Glyph). */
+    icon?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+declare function Notice({ tone, title, icon, children, className }: NoticeProps): react.JSX.Element;
+interface DescriptionListProps {
+    children?: ReactNode;
+    /**
+     * Layout der Label/Wert-Paare:
+     * - `stacked` (Default): Label über dem Wert.
+     * - `inline`: Label links, Wert rechts (zweispaltig).
+     */
+    layout?: "stacked" | "inline";
+    className?: string;
+}
+/** Schlanke read-only Label/Wert-Liste (semantisches `<dl>`). */
+declare function DescriptionList({ children, layout, className, }: DescriptionListProps): react.JSX.Element;
+interface FieldProps {
+    label: ReactNode;
+    /** Anzuzeigender Wert (read-only). */
+    value?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}
+/** Ein read-only Label/Wert-Paar (`<dt>`/`<dd>`) für `DescriptionList`. */
+declare function Field({ label, value, children, className }: FieldProps): react.JSX.Element;
+
+/** Eintrag im Titel-Dropdown (analog UI5 `menuItems`). */
+interface AppShellMenuItem {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+}
+/** Aktions-Item in der Shell-Bar (analog UI5 `ShellBarItem`). */
+interface AppShellItem {
+    id: string;
+    /** Monochromes Icon (z. B. `<Icon name="bell" />`). */
+    icon: ReactNode;
+    /** Zugängliches Label (Tooltip/aria-label, Overflow-Text). */
+    label: string;
+    /** Optionaler Zähler-Badge. */
+    count?: ReactNode;
+    onClick?: () => void;
+}
+interface AppShellProps {
+    /** App-Titel (Primärtitel). */
+    title?: ReactNode;
+    /** Untertitel — blendet auf schmalen Screens aus. */
+    subtitle?: ReactNode;
+    /** Marken-/Logo-Slot ganz links. */
+    logo?: ReactNode;
+    onLogoClick?: () => void;
+    /** Macht den Titel zu einem Dropdown (analog UI5 `menuItems`). */
+    menuItems?: AppShellMenuItem[];
+    onMenuItemClick?: (id: string) => void;
+    /** Globale Suche; kollabiert auf Mobile zu einem Icon (aufklappbar). */
+    search?: ReactNode;
+    /** Freie Aktionen rechts (Buttons o. Ä.). */
+    actions?: ReactNode;
+    /** Aktions-Items mit Icon/Count; wandern auf schmalen Screens ins „…"-Overflow-Menü. */
+    items?: AppShellItem[];
+    /** Benachrichtigungs-Glocke mit optionalem Zähler. */
+    notifications?: boolean;
+    notificationsCount?: ReactNode;
+    onNotificationsClick?: () => void;
+    /** Produkt-Wechsler (Grid-Icon). */
+    productSwitch?: boolean;
+    onProductSwitchClick?: () => void;
+    /** User-/Account-Slot ganz rechts (Avatar). */
+    user?: ReactNode;
+    onProfileClick?: () => void;
+    /** Slot ganz am Anfang der Bar (vor dem Menü-Toggle). */
+    startButton?: ReactNode;
+    /** Seitennavigation — typischerweise ein `<Sidebar/>` (ohne eigenes `glass`). */
+    sidebar?: ReactNode;
+    sidebarCollapsed?: boolean;
+    defaultSidebarCollapsed?: boolean;
+    onSidebarCollapsedChange?: (collapsed: boolean) => void;
+    /** „Liquid Glass"-Optik auf Shell-Bar + Sidebar (Default: true). */
+    glass?: boolean;
+    toggleLabel?: string;
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * AppShell — Apple-orientierte App-Hülle mit voller ShellBar-Funktion
+ * (vgl. SAP UI5 ShellBar): Logo, Titel + Untertitel + Titel-Dropdown, Suche
+ * (auf Mobile kollabierbar), Aktions-Items mit Overflow, Benachrichtigungen,
+ * Produkt-Wechsler, Profil — plus Sidebar (Off-canvas auf Mobile) und Content.
+ *
+ * Reine Optik/Layout/Komposition; Verhalten von Menüs/Overlays kommt aus den
+ * React-Aria-Primitiven (`Menu`). Glas (Default) liegt auf Shell-Bar + Sidebar.
+ * Responsives Verhalten über CSS-Breakpoints (Phone ≤767, Tablet ≤1024).
+ */
+declare function AppShell({ title, subtitle, logo, onLogoClick, menuItems, onMenuItemClick, search, actions, items, notifications, notificationsCount, onNotificationsClick, productSwitch, onProductSwitchClick, user, onProfileClick, startButton, sidebar, sidebarCollapsed, defaultSidebarCollapsed, onSidebarCollapsedChange, glass, toggleLabel, children, className, }: AppShellProps): react.JSX.Element;
+
+type LaunchpadSpan = 1 | 2 | 3 | 4;
+type Trend = "up" | "down" | "flat";
+type Tone = "positive" | "critical" | "negative";
+interface BaseCard {
+    id: string;
+    span?: LaunchpadSpan;
+}
+interface LpNavCard extends BaseCard {
+    kind: "nav";
+    title: ReactNode;
+    icon?: ReactNode;
+    description?: ReactNode;
+    badge?: ReactNode;
+    onPress?: () => void;
+}
+interface LpKpiCard extends BaseCard {
+    kind: "kpi";
+    title: ReactNode;
+    value: ReactNode;
+    delta?: ReactNode;
+    trend?: Trend;
+    tone?: Tone;
+    icon?: ReactNode;
+    accent?: boolean;
+    onPress?: () => void;
+}
+interface LpTrendCard extends BaseCard {
+    kind: "trend";
+    title: ReactNode;
+    value?: ReactNode;
+    delta?: ReactNode;
+    trend?: Trend;
+    data: number[];
+    /** Voll-Visualisierung im Drill-down-Popup (Default: großer AreaChart). */
+    detail?: ReactNode;
+}
+interface LpListRowModel {
+    id: string;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    onPress?: () => void;
+}
+interface LpListCard extends BaseCard {
+    kind: "list";
+    title: ReactNode;
+    icon?: ReactNode;
+    count?: ReactNode;
+    rows: LpListRowModel[];
+    /** Max. sichtbare Zeilen (Rest im Popup). Default 4. */
+    maxRows?: number;
+    onShowAll?: () => void;
+    detail?: ReactNode;
+}
+interface LpCustomCard extends BaseCard {
+    kind: "custom";
+    title?: ReactNode;
+    icon?: ReactNode;
+    render: () => ReactNode;
+    detail?: ReactNode;
+}
+type LaunchpadCard = LpNavCard | LpKpiCard | LpTrendCard | LpListCard | LpCustomCard;
+interface LaunchpadSection {
+    id: string;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    icon?: ReactNode;
+    cards: LaunchpadCard[];
+}
+interface LaunchpadProps {
+    sections: LaunchpadSection[];
+    /** Aktiviert Drag-&-Drop-Reorder (react-aria, Tastatur + Pointer). */
+    editable?: boolean;
+    onReorder?: (sectionId: string, orderedCardIds: string[]) => void;
+    className?: string;
+}
+/**
+ * Launchpad — komponiert Sections aus polymorphen Cards (`kind`).
+ * `editable` schaltet Drag-Reorder frei; Cards mit `detail`/`trend`
+ * öffnen ein Drill-down-Popup mit der Voll-Visualisierung.
+ */
+declare function Launchpad({ sections, editable, onReorder, className }: LaunchpadProps): react.JSX.Element;
+
+/** Ein normalisierter (x,y)-Punkt im Koordinatenraum des viewBox. */
+interface Pt {
+    x: number;
+    y: number;
+}
+/**
+ * Catmull-Rom → kubische Bézier-Glättung.
+ * Erzeugt ein weiches `d`-Pfad-Fragment (ohne führendes `M`) durch alle Punkte.
+ * Bei < 2 Punkten bleibt der Pfad leer; bei genau 2 Punkten eine gerade Linie.
+ */
+declare function smoothPath(points: Pt[], tension?: number): string;
+interface SparklineProps {
+    data: number[];
+    /** viewBox-Breite (interne Einheiten); skaliert responsiv. */
+    width?: number;
+    /** viewBox-Höhe (interne Einheiten). */
+    height?: number;
+    /** Linienfarbe; Default --prn-chart-1. */
+    color?: string;
+    className?: string;
+}
+/** Kompakte, geglättete Trendlinie ohne Achsen — für KPI-Kacheln. */
+declare function Sparkline({ data, width, height, color, className }: SparklineProps): react.JSX.Element;
+interface AreaChartProps {
+    /** Entweder reine Werte (gleichmäßig verteilt) oder explizite (x,y)-Punkte. */
+    data: number[] | Pt[];
+    width?: number;
+    height?: number;
+    color?: string;
+    /** Achsen + horizontale Gridlinien anzeigen. */
+    showAxes?: boolean;
+    className?: string;
+}
+/** Flächenchart mit Gradient-Füllung unter geglätteter Linie, optionale Achsen/Grid. */
+declare function AreaChart({ data, width, height, color, showAxes, className }: AreaChartProps): react.JSX.Element;
+interface BarDatum {
+    label: string;
+    value: number;
+}
+interface BarChartProps {
+    data: BarDatum[];
+    width?: number;
+    height?: number;
+    color?: string;
+    /** x-Achsenbeschriftung anzeigen. */
+    showLabels?: boolean;
+    className?: string;
+}
+/** Vertikale Balken mit gerundeten Köpfen, optionale x-Labels. */
+declare function BarChart({ data, width, height, color, showLabels, className }: BarChartProps): react.JSX.Element;
+interface DonutSegment {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface DonutChartProps {
+    segments: DonutSegment[];
+    /** Text in der Ringmitte (z. B. Summe). */
+    centerLabel?: ReactNode;
+    /** Kantenlänge des SVG (interne Einheiten). */
+    size?: number;
+    /** Ringdicke relativ zum Radius (0..1). */
+    thickness?: number;
+    /** Legende mit Label + Wert anzeigen. */
+    showLegend?: boolean;
+    className?: string;
+}
+/** Ring-Diagramm aus SVG-Arcs mit zentralem Label und Legende. */
+declare function DonutChart({ segments, centerLabel, size, thickness, showLegend, className, }: DonutChartProps): react.JSX.Element;
+interface ChartEmptyProps {
+    /** Hinweistext im Leerzustand. */
+    message?: string;
+    /** Kompakte Variante (z. B. für Sparkline-Slot). */
+    compact?: boolean;
+    className?: string;
+}
+/** Leerzustand, wenn keine Datenpunkte vorliegen. */
+declare function ChartEmpty({ message, compact, className }: ChartEmptyProps): react.JSX.Element;
+
+interface ColMeta {
+    align?: "start" | "end";
+    vAlign?: "top" | "middle" | "bottom";
+    width?: string;
+    minWidth?: number;
+    maxWidth?: number;
+    isSelect?: boolean;
+    isTree?: boolean;
+    headerTooltip?: string;
+    headerLabel?: string;
+    cellLabel?: string;
+    responsivePopIn?: boolean;
+    responsiveMinWidth?: number;
+    popinDisplay?: "block" | "inline";
+    autoResizable?: boolean;
+    /** Custom-Filter-Render-Slot (per-Spalte). */
+    renderFilter?: (info: {
+        value: string;
+        setValue: (v: string | undefined) => void;
+    }) => ReactNode;
+    /** Custom-Header-Popover-Inhalt (per-Spalte). */
+    renderHeaderPopover?: () => ReactNode;
+}
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData extends RowData, TValue> extends ColMeta {
+    }
+}
+type AggregateType = "sum" | "count" | "avg" | "min" | "max" | "minMax" | "median" | "unique" | "uniqueCount";
+type SortType = "alphanumeric" | "basic" | "datetime";
+type ColumnFilterType = "text" | "exactText" | "exactTextCase" | "equals";
+interface AnalyticalColumn<T> {
+    /** Stabile ID. Default: `accessorKey` falls gesetzt. */
+    id?: string;
+    /** Spaltenüberschrift. */
+    header: ReactNode;
+    /** Feldname für den Standard-Wert (typsicher gegen T). Unterstützt nested paths "info.hobby". */
+    accessorKey?: (keyof T & string) | string;
+    /** Eigener Wert-Resolver (überschreibt accessorKey für die Anzeige). */
+    accessor?: (row: T) => unknown;
+    /** Eigenes Zell-Rendering. */
+    cellRender?: (row: T) => ReactNode;
+    /** Feste/Initial-Breite, z. B. `120px`, `1fr`, `minmax(120px, 1fr)`. Default `1fr`. */
+    width?: string;
+    /** Mindestbreite in px (für Resizing/minmax). */
+    minWidth?: number;
+    /** Maximalbreite in px. */
+    maxWidth?: number;
+    /** Ausrichtung. `end` aktiviert tabular-nums (für Zahlen). */
+    align?: "start" | "end";
+    /** Vertikale Ausrichtung der Zelle. */
+    vAlign?: "top" | "middle" | "bottom";
+    /** Sortierung erlauben (Default true). */
+    sortable?: boolean;
+    /** Sortierung pro Spalte deaktivieren (SAP-Alias zu sortable:false). */
+    disableSortBy?: boolean;
+    /** Sortier-Typ. */
+    sortType?: SortType;
+    /** Bei erstem Klick absteigend statt aufsteigend sortieren (B2). */
+    sortDescFirst?: boolean;
+    /** Sortier-Richtung invertieren (asc↔desc), z. B. für Rang/Score (B2). */
+    sortInverted?: boolean;
+    /** Filterung pro Spalte erlauben (Default: globales `filterable`). */
+    filterable?: boolean;
+    /** Filterung pro Spalte deaktivieren. */
+    disableFilters?: boolean;
+    /** Spalte aus dem globalen Filter ausnehmen (B3). */
+    disableGlobalFilter?: boolean;
+    /** Filter-Vergleichsfunktion. Default "text". */
+    filter?: ColumnFilterType;
+    /** Eigener Filter-Render-Slot im Header-Popover (überschreibt das TextField). */
+    Filter?: (info: {
+        value: string;
+        setValue: (v: string | undefined) => void;
+    }) => ReactNode;
+    /** Freier Custom-Popover-Inhalt am Spaltenkopf (B1.5). */
+    Popover?: () => ReactNode;
+    /** Spalte darf gruppiert werden. */
+    groupable?: boolean;
+    /** Resizing pro Spalte deaktivieren. */
+    disableResizing?: boolean;
+    /** Doppelklick auf den Resizer passt die Breite an den Inhalt an (B6). */
+    autoResizable?: boolean;
+    /** Drag&Drop-Reorder pro Spalte deaktivieren. */
+    disableDragAndDrop?: boolean;
+    /** Aggregation je Gruppe für diese Spalte. */
+    aggregate?: AggregateType | ((values: unknown[], rows: T[]) => unknown);
+    /** Vorberechnung des Aggregat-Werts vor der Aggregation (B4). */
+    aggregateValue?: (row: T) => unknown;
+    /** Eigenes Rendering des Aggregat-Werts. */
+    aggregatedCellRender?: (info: {
+        value: unknown;
+        rows: T[];
+    }) => ReactNode;
+    /** Darf ausgeblendet werden (Default true). */
+    canHide?: boolean;
+    /** Darf gepinnt werden (Default false). */
+    canPin?: boolean;
+    /** Initiale Pin-Seite. */
+    defaultPinned?: "left" | "right";
+    /** Tooltip am Spaltenkopf. */
+    headerTooltip?: string;
+    /** Barrierefreies Label für die Spalte (überschreibt header für a11y). */
+    headerLabel?: string;
+    /** Barrierefreies Label pro Zelle. */
+    cellLabel?: string;
+    /** Klappt diese Spalte in die erste Zelle, wenn die Tabelle schmal wird. */
+    responsivePopIn?: boolean;
+    /** Tabellenbreite (px), unter der diese Spalte zur Pop-In wird. */
+    responsiveMinWidth?: number;
+    /** Anzeigeform im Pop-In. */
+    popinDisplay?: "block" | "inline";
+}
+type SelectionMode = "none" | "single" | "multiple";
+type SelectionBehavior = "row" | "rowOnly" | "rowSelector";
+type VisibleRowCountMode = "fixed" | "auto" | "autoWithEmptyRows";
+type ValueState = "none" | "information" | "positive" | "critical" | "negative";
+type NoDataReason = "empty" | "filtered";
+type SubComponentsBehavior = "expandable" | "visible";
+type ScaleWidthMode = "default" | "smart" | "grow";
+interface AnalyticalTableProps<T> {
+    /** Datenzeilen. */
+    data: T[];
+    /** Spalten-Beschreibung. */
+    columns: AnalyticalColumn<T>[];
+    /** Eindeutige Zeilen-ID (für Selektion/Keys). Default: Array-Index. */
+    getRowId?: (row: T, index: number) => string;
+    /** Selektionsmodus. */
+    selectionMode?: SelectionMode;
+    /** Selektionsverhalten: row = ganze Zeile selektiert + onRowClick; rowSelector = nur über Checkbox. */
+    selectionBehavior?: SelectionBehavior;
+    /** Alias auf selectionMode="multiple" (rückwärtskompatibel). */
+    selectable?: boolean;
+    /** Kontrollierte Auswahl (Set ausgewählter Row-IDs). */
+    selectedKeys?: Set<string>;
+    /** Callback bei Auswahländerung. */
+    onSelectionChange?: (keys: Set<string>) => void;
+    /** SAP-Style Selektions-Event. */
+    onRowSelect?: (info: {
+        row: T;
+        selected: boolean;
+        selectedKeys: Set<string>;
+    }) => void;
+    /** Aktion bei Zeilen-Aktivierung (Klick/Enter/Space) — rückwärtskompatibel. */
+    onRowAction?: (row: T) => void;
+    /** Klick-Event auf eine Zeile (mit Event-Objekt). */
+    onRowClick?: (info: {
+        row: T;
+        event: MouseEvent;
+    }) => void;
+    /** Rechtsklick-Kontextmenü auf eine Zeile. */
+    onRowContextMenu?: (info: {
+        row: T;
+        event: MouseEvent;
+    }) => void;
+    /** Globales Sortier-Flag (Default true für Spalten ohne explizites sortable). */
+    sortable?: boolean;
+    /** Kontrollierte Sortierung. */
+    sorting?: {
+        id: string;
+        desc: boolean;
+    }[];
+    /** Anfangs-Sortierung (unkontrolliert). */
+    defaultSorting?: {
+        id: string;
+        desc: boolean;
+    }[];
+    /** Callback bei Sortier-Änderung (controlled-Pattern). */
+    onSortingChange?: (sorting: {
+        id: string;
+        desc: boolean;
+    }[]) => void;
+    /** SAP-Style Sort-Event. */
+    onSort?: (sorting: {
+        id: string;
+        desc: boolean;
+    }[]) => void;
+    /** Multi-Sort via Shift-Klick. */
+    enableMultiSort?: boolean;
+    /** Spaltenfilter global aktivieren (Header-Popover). */
+    filterable?: boolean;
+    /** Globaler Filter über alle Zeilen. */
+    globalFilterValue?: string;
+    /** Callback bei Filter-Änderung (Spaltenfilter). */
+    onFilter?: (filters: {
+        id: string;
+        value: string;
+    }[]) => void;
+    /** Ladezustand. */
+    loading?: boolean;
+    /** Alias auf loading (rückwärtskompatibel). */
+    isLoading?: boolean;
+    /** Verzögerung in ms, bevor der Ladeindikator erscheint. */
+    loadingDelay?: number;
+    /** BusyIndicator statt Skeleton anzeigen. */
+    alwaysShowBusyIndicator?: boolean;
+    /** Halbtransparentes Overlay über vorhandenen Daten. */
+    showOverlay?: boolean;
+    /** Anzahl Skeleton-Zeilen (Default 8). */
+    skeletonRows?: number;
+    /** Leerzustands-Titel (rückwärtskompatibel). */
+    emptyTitle?: ReactNode;
+    emptyDescription?: ReactNode;
+    /** Text im Leerzustand (SAP `noDataText`). */
+    noDataText?: ReactNode;
+    /** Eigene Leerzustands-Komponente. */
+    NoDataComponent?: (info: {
+        reason: NoDataReason;
+    }) => ReactNode;
+    /** Geschätzte Zeilenhöhe für die Virtualisierung (Default 44). */
+    rowHeight?: number;
+    /** Höhe der Kopfzeile (px). */
+    headerRowHeight?: number;
+    /** Anzahl sichtbarer Zeilen → bestimmt die Tabellenhöhe. */
+    visibleRows?: number;
+    /** Mindestzeilenzahl (Leerzeilen-Auffüllung). */
+    minRows?: number;
+    /** Höhenmodus. */
+    visibleRowCountMode?: VisibleRowCountMode;
+    /** Overscan der Virtualisierung (Default 10). */
+    overscanCount?: number;
+    /** Scroll-Event des Viewports. */
+    onTableScroll?: (info: {
+        scrollTop: number;
+        scrollLeft: number;
+    }) => void;
+    /** Max. Höhe des Scroll-Viewports (Fallback, wenn keine visibleRows). Default `480px`. */
+    maxHeight?: number | string;
+    /** Aktiviert hierarchische Zeilen. */
+    isTreeTable?: boolean;
+    /** Feld, das Kindzeilen enthält (Default "subRows"). */
+    subRowsKey?: string;
+    /** Callback bei Expand/Collapse einer Zeile. */
+    onRowExpandChange?: (info: {
+        row: T;
+        expanded: boolean;
+    }) => void;
+    /** Aktiviert Nachladen beim Scrollen. */
+    infiniteScroll?: boolean;
+    /** Abstand (px) vom Ende, ab dem onLoadMore feuert (Default 20). */
+    infiniteScrollThreshold?: number;
+    /** Callback zum Nachladen. */
+    onLoadMore?: () => void;
+    /** Zebra-Streifen. */
+    alternateRowColor?: boolean;
+    /** Farbband links je Zeile (ValueState). */
+    withRowHighlight?: boolean;
+    /** Feld, das die ValueState pro Zeile liefert. */
+    highlightField?: (row: T) => ValueState;
+    /** Navigations-Pfeil-Spalte aktivieren. */
+    withNavigationHighlight?: boolean;
+    /** Markiert die navigierte Zeile (true = Pfeil hervorgehoben). */
+    markNavigatedRow?: (row: T) => boolean;
+    /** Aktuelle Tabellenbreite (px) für Pop-In-Berechnung (Test-/SSR-Hilfe). */
+    tableWidth?: number;
+    /** Sichtbarer Tabellen-Titel (auch accessible name). */
+    header?: ReactNode;
+    /** Bereich über der Tabelle (Toolbar/FilterBar). */
+    extension?: ReactNode;
+    /** „Liquid Glass"-Optik auf der Tabellen-Toolbar (NICHT auf den dichten Zeilen). */
+    glass?: boolean;
+    /** Barrierefreies Label der Tabelle. */
+    accessibleName?: string;
+    /** ID eines Elements als aria-labelledby. */
+    accessibleNameRef?: string;
+    className?: string;
+    /** Barrierefreies Label (rückwärtskompatibel). */
+    "aria-label"?: string;
+    /** Column-Resizing global aktivieren. */
+    enableColumnResizing?: boolean;
+    /** Manuell gesetzte Spaltenbreiten bei Container-Resize behalten (B6). */
+    retainColumnWidth?: boolean;
+    /** Breiten-Skalierungsmodus (B6). */
+    scaleWidthMode?: ScaleWidthMode;
+    /** Callback bei Auto-Resize (Doppelklick auf Resizer einer `autoResizable`-Spalte). */
+    onAutoResize?: (info: {
+        columnId: string;
+        width: number;
+    }) => void;
+    /** Drag&Drop-Reorder aktivieren. */
+    enableColumnReorder?: boolean;
+    /** Callback bei Reorder per Drag&Drop. */
+    onColumnsReorder?: (order: string[]) => void;
+    /** Aktiviert Gruppierung + Group-Bar. */
+    enableGrouping?: boolean;
+    /** Kontrollierte Gruppierung (geordnete Spalten-IDs). */
+    grouping?: string[];
+    /** Unkontrollierte Anfangs-Gruppierung. */
+    defaultGrouping?: string[];
+    /** Callback bei Änderung der Gruppierung. */
+    onGroupingChange?: (grouping: string[]) => void;
+    /** SAP-Style Group-Event. */
+    onGroup?: (grouping: string[]) => void;
+    /** Aktiviert Spalten-Personalisierung (⚙-Menü: Sichtbarkeit/Reihenfolge/Pinning). */
+    enablePersonalization?: boolean;
+    /** Kontrollierte Spaltensichtbarkeit. */
+    columnVisibility?: Record<string, boolean>;
+    /** Unkontrollierte Anfangs-Sichtbarkeit. */
+    defaultColumnVisibility?: Record<string, boolean>;
+    /** Callback bei Sichtbarkeitsänderung. */
+    onColumnVisibilityChange?: (v: Record<string, boolean>) => void;
+    /** Kontrollierte Spaltenreihenfolge. */
+    columnOrder?: string[];
+    /** Unkontrollierte Anfangs-Reihenfolge. */
+    defaultColumnOrder?: string[];
+    /** Callback bei Reihenfolgeänderung. */
+    onColumnOrderChange?: (o: string[]) => void;
+    /** Kontrolliertes Spalten-Pinning. */
+    columnPinning?: {
+        left?: string[];
+        right?: string[];
+    };
+    /** Unkontrolliertes Anfangs-Pinning. */
+    defaultColumnPinning?: {
+        left?: string[];
+        right?: string[];
+    };
+    /** Callback bei Pinning-Änderung. */
+    onColumnPinningChange?: (p: {
+        left?: string[];
+        right?: string[];
+    }) => void;
+    /** Rendert eine Unterkomponente unter einer Zeile. */
+    renderRowSubComponent?: (info: {
+        row: T;
+    }) => ReactNode;
+    /** Verhalten der Unterkomponente: ausklappbar (Chevron) oder immer sichtbar. */
+    subComponentsBehavior?: SubComponentsBehavior;
+    /** Wird in useReactTable hineingemerged (Escape-Hatch). */
+    reactTableOptions?: Partial<TableOptions<T>>;
+    /** Liefert die TanStack-Tabellen-Instanz nach oben. */
+    onTableReady?: (table: Table$1<T>) => void;
+}
+declare function AnalyticalTable<T>(props: AnalyticalTableProps<T>): react.JSX.Element;
+
+interface FilterFieldProps {
+    /** Sichtbares Label über dem Control. */
+    label?: ReactNode;
+    /** Das Eingabe-Control (Select, TextField, …). */
+    children: ReactNode;
+    className?: string;
+}
+declare function FilterField({ label, children, className }: FilterFieldProps): react.JSX.Element;
+interface ActiveFilter {
+    /** Stabile ID des Filters (z. B. Feldname). */
+    id: string;
+    /** Label, z. B. "Sparte". */
+    label?: ReactNode;
+    /** Aktiver Wert, z. B. "Strom". */
+    value: ReactNode;
+}
+interface FilterBarProps {
+    /** Direkt sichtbare Filter-Felder (`FilterField`). */
+    children: ReactNode;
+    /** In den "Mehr Filter"-Überlauf ausgelagerte Felder. */
+    moreFields?: ReactNode;
+    /** Beschriftung des Überlauf-Buttons. */
+    moreLabel?: ReactNode;
+    /** Aktuell aktive Filter → werden als Chips gezeigt. */
+    activeFilters?: ActiveFilter[];
+    /** Einzelnen Filter entfernen (X am Chip). */
+    onRemoveFilter?: (id: string) => void;
+    /** Alle Filter zurücksetzen ("Zurücksetzen"-Aktion, nur bei aktiven Filtern). */
+    onClearAll?: () => void;
+    /** Zusätzliche Aktionen rechts (z. B. "Anwenden", Suche). */
+    actions?: ReactNode;
+    className?: string;
+    "aria-label"?: string;
+}
+declare function FilterBar({ children, moreFields, moreLabel, activeFilters, onRemoveFilter, onClearAll, actions, className, "aria-label": ariaLabel, }: FilterBarProps): react.JSX.Element;
+
+type StatusTone = "positive" | "critical" | "negative" | "info" | "neutral";
+interface StatusBadge {
+    label: ReactNode;
+    tone?: StatusTone;
+}
+interface ObjectPageKpi {
+    label: ReactNode;
+    value: ReactNode;
+    /** Färbt den Wert (z. B. positive/negative Kennzahl). */
+    tone?: "positive" | "critical" | "negative";
+}
+interface ObjectField {
+    label: ReactNode;
+    value: ReactNode;
+    /** Zahl-Wert → tabular-nums + rechtsbündige Ziffern. */
+    numeric?: boolean;
+}
+interface ObjectSection {
+    title?: ReactNode;
+    fields: ObjectField[];
+}
+type ObjectPageMode = "default" | "iconTabBar";
+/** Heading-Level → aria-level / Tag. */
+type TitleTextLevel = "H1" | "H2" | "H3" | "H4" | "H5" | "H6";
+interface ObjectPageSectionProps {
+    /** Eindeutige ID — Anker-Ziel & Selektions-Schlüssel. (Pflicht) */
+    id: string;
+    /** Sichtbarer Titel der Sektion. (Pflicht) */
+    titleText: string;
+    children?: ReactNode;
+    /** Titel ausblenden (Anchor-Bar nutzt weiterhin titleText). */
+    hideTitleText?: boolean;
+    /** Titel in Großbuchstaben darstellen. */
+    titleTextUppercase?: boolean;
+    /** Langen Titel umbrechen statt kürzen. */
+    wrapTitleText?: boolean;
+    /** Überschriften-Level (H1..H6) → aria-level + Tag. Default H3. */
+    titleTextLevel?: TitleTextLevel;
+    /** Custom-Header-Inhalt rechts neben dem Titel. */
+    header?: ReactNode;
+    className?: string;
+}
+/**
+ * Top-Level-Informationscontainer. Wird ausschließlich als child der
+ * ObjectPage gerendert; standalone ist es ein neutraler Container.
+ */
+declare function ObjectPageSection(props: ObjectPageSectionProps): react.JSX.Element;
+interface ObjectPageSubSectionProps {
+    /** Eindeutige ID. (Pflicht) */
+    id: string;
+    /** Sichtbarer Titel. (Pflicht) */
+    titleText: string;
+    children?: ReactNode;
+    /** Aktionen rechts im SubSection-Kopf. */
+    actions?: ReactNode;
+    /** Titel ausblenden. */
+    hideTitleText?: boolean;
+    className?: string;
+}
+/** Zweite Ebene innerhalb einer Section. */
+declare function ObjectPageSubSection(props: ObjectPageSubSectionProps): react.JSX.Element;
+interface ObjectPageAccessibilityAttributes {
+    objectPageTopHeader?: {
+        role?: string;
+        "aria-label"?: string;
+    };
+    objectPageAnchorBar?: {
+        role?: string;
+        "aria-label"?: string;
+    };
+    objectPageFooterActions?: {
+        role?: string;
+        "aria-label"?: string;
+    };
+}
+interface ObjectPageHandle {
+    /** Snappt/entsnappt den Header. Ohne Argument: Toggle. */
+    toggleHeaderArea: (snapped?: boolean) => void;
+}
+interface SelectedSectionChangeDetail {
+    selectedSectionIndex: number;
+    selectedSectionId: string;
+}
+interface BeforeNavigateDetail {
+    sectionId: string;
+    sectionIndex: number;
+    /** Bricht die Navigation ab. */
+    preventDefault: () => void;
+}
+interface ObjectPageProps {
+    title: ReactNode;
+    subtitle?: ReactNode;
+    /** Status-Badge rechts im Kopf. */
+    status?: StatusBadge;
+    /** KPI-Reihe im Title-Bereich. */
+    kpis?: ObjectPageKpi[];
+    /** Aktionen rechts im Kopf (actionsBar). */
+    actions?: ReactNode;
+    /** Breadcrumb-Slot über dem Titel. */
+    breadcrumbs?: ReactNode;
+    /** Frei komponierbarer Kopf-/Unterkopf (überschreibt title/subtitle, wenn gesetzt). */
+    header?: ReactNode;
+    subHeader?: ReactNode;
+    /** Alternative Darstellung im kollabierten (snapped) Zustand. */
+    snappedHeader?: ReactNode;
+    snappedSubHeader?: ReactNode;
+    /** Inhalt nur im expandierten bzw. nur im snapped Zustand. */
+    expandedContent?: ReactNode;
+    snappedContent?: ReactNode;
+    /** Aktionsleiste (Alias zu actions; actions hat Vorrang). */
+    actionsBar?: ReactNode;
+    /** Navigations-Aktionen, responsiv positioniert. */
+    navigationBar?: ReactNode;
+    /** „Liquid Glass"-Optik auf der Title-/Top-Header-Leiste (transluzent + Blur). */
+    glass?: boolean;
+    /** Expandierbarer Header-Content unter dem Title. */
+    headerArea?: ReactNode;
+    /** Header fixiert (nicht kollabierbar beim Scrollen). */
+    headerPinned?: boolean;
+    /** Pin-Button ausblenden. */
+    hidePinButton?: boolean;
+    /** Klick auf Title togglet den Header nicht. */
+    preserveHeaderStateOnClick?: boolean;
+    onToggleHeaderArea?: (visible: boolean) => void;
+    onPinButtonToggle?: (pinned: boolean) => void;
+    /** Bild/Avatar im Kopf — URL-String oder beliebiger Node. */
+    image?: string | ReactNode;
+    /** Bild rund darstellen. */
+    imageShapeCircle?: boolean;
+    /** Schwebende Footer-Aktionsleiste. */
+    footerArea?: ReactNode;
+    /** Ersetzt den gesamten Inhalt (z. B. „nicht ladbar"). */
+    placeholder?: ReactNode;
+    /** `default` = alle Sektionen scrollbar, `iconTabBar` = nur aktive sichtbar. */
+    mode?: ObjectPageMode;
+    /** Controlled aktive Sektion. */
+    selectedSectionId?: string;
+    /** Controlled aktive SubSection (nur Markierung). */
+    selectedSubSectionId?: string;
+    onSelectedSectionChange?: (detail: SelectedSectionChangeDetail) => void;
+    /** Cancelable vor jeder Navigation. */
+    onBeforeNavigate?: (detail: BeforeNavigateDetail) => void;
+    accessibilityAttributes?: ObjectPageAccessibilityAttributes;
+    /** Detail-Sektionen (Legacy-Adapter → ObjectPageSection). */
+    sections?: ObjectSection[];
+    /** Kompositions-children (ObjectPageSection-Elemente) bzw. freier Inhalt. */
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+declare const ObjectPage: react.ForwardRefExoticComponent<ObjectPageProps & react.RefAttributes<ObjectPageHandle>>;
+
+interface UseFilterStateOptions<V extends Record<string, unknown>> {
+    /** localStorage-Schlüssel-Suffix (eindeutig pro Tabelle/View). */
+    persistKey: string;
+    /** Startwerte; definieren zugleich die Filter-Keys. */
+    defaultValues: V;
+    /** Labels für die abgeleiteten activeFilters-Chips. */
+    labels?: Partial<Record<keyof V, ReactNode>>;
+    /** Ob ein Wert als „aktiv" zählt. Default: != default und nicht leer. */
+    isActive?: (key: keyof V, value: unknown, defaultValue: unknown) => boolean;
+}
+interface UseFilterStateResult<V> {
+    values: V;
+    setValue: <K extends keyof V>(key: K, value: V[K]) => void;
+    setValues: (patch: Partial<V>) => void;
+    reset: () => void;
+    activeFilters: ActiveFilter[];
+}
+declare function useFilterState<V extends Record<string, unknown>>(options: UseFilterStateOptions<V>): UseFilterStateResult<V>;
+
+interface RadioGroupProps extends Omit<RadioGroupProps$1, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+declare function RadioGroup({ label, description, errorMessage, children, className, ...props }: RadioGroupProps): react.JSX.Element;
+interface RadioProps extends Omit<RadioProps$1, "className"> {
+    children?: ReactNode;
+    className?: string;
+}
+declare function Radio({ children, className, ...props }: RadioProps): react.JSX.Element;
+interface CheckboxGroupProps extends Omit<CheckboxGroupProps$1, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+declare function CheckboxGroup({ label, description, errorMessage, children, className, ...props }: CheckboxGroupProps): react.JSX.Element;
+
+interface NumberFieldProps extends Omit<NumberFieldProps$1, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    className?: string;
+}
+declare function NumberField({ label, description, errorMessage, placeholder, className, ...props }: NumberFieldProps): react.JSX.Element;
+interface SliderProps extends Omit<SliderProps$1, "className"> {
+    label?: ReactNode;
+    showValue?: boolean;
+    className?: string;
+}
+declare function Slider({ label, showValue, className, ...props }: SliderProps): react.JSX.Element;
+
+interface ComboBoxProps<T extends object> extends Omit<ComboBoxProps$1<T>, "className" | "children"> {
+    label?: ReactNode;
+    placeholder?: string;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    children: ReactNode | ((item: T) => ReactNode);
+    className?: string;
+}
+declare function ComboBox<T extends object>({ label, placeholder, description, errorMessage, children, className, ...props }: ComboBoxProps<T>): react.JSX.Element;
+interface ComboBoxItemProps extends Omit<ListBoxItemProps, "className"> {
+    className?: string;
+}
+declare function ComboBoxItem({ className, ...props }: ComboBoxItemProps): react.JSX.Element;
+
+interface FormProps extends Omit<FormProps$1, "className"> {
+    className?: string;
+}
+declare function Form({ className, ...props }: FormProps): react.JSX.Element;
+interface FieldErrorProps extends Omit<FieldErrorProps$1, "className"> {
+    className?: string;
+}
+declare function FieldError({ className, ...props }: FieldErrorProps): react.JSX.Element;
+
+interface ListBoxProps<T extends object> extends Omit<ListBoxProps$1<T>, "className"> {
+    className?: string;
+}
+declare function ListBox<T extends object>({ className, ...props }: ListBoxProps<T>): react.JSX.Element;
+interface ListBoxOptionProps extends Omit<ListBoxItemProps, "className"> {
+    className?: string;
+}
+declare function ListBoxOption({ className, ...props }: ListBoxOptionProps): react.JSX.Element;
+interface GridListProps<T extends object> extends Omit<GridListProps$1<T>, "className"> {
+    className?: string;
+}
+declare function GridList<T extends object>({ className, ...props }: GridListProps<T>): react.JSX.Element;
+interface GridListItemProps extends Omit<GridListItemProps$1, "className"> {
+    className?: string;
+    children?: ReactNode;
+}
+declare function GridListItem({ className, children, ...props }: GridListItemProps): react.JSX.Element;
+interface TagGroupProps<T extends object> extends Omit<TagGroupProps$1, "className" | "children"> {
+    /** Optionales Label über der Chip-Reihe. */
+    label?: ReactNode;
+    /** Tags als statische Children oder via items/renderTag. */
+    children: ReactNode;
+    /** Inhalt, wenn keine Tags vorhanden sind. */
+    renderEmptyState?: TagListProps<T>["renderEmptyState"];
+    /** Dynamische Item-Quelle für die TagList. */
+    items?: TagListProps<T>["items"];
+    className?: string;
+}
+declare function TagGroup<T extends object>({ label, children, renderEmptyState, items, className, ...props }: TagGroupProps<T>): react.JSX.Element;
+interface TagProps extends Omit<TagProps$1, "className"> {
+    children?: ReactNode;
+    className?: string;
+}
+declare function Tag({ children, className, textValue, ...props }: TagProps): react.JSX.Element;
+
+interface BreadcrumbsProps<T extends object> extends Omit<BreadcrumbsProps$1<T>, "className"> {
+    className?: string;
+}
+declare function Breadcrumbs<T extends object>({ className, ...props }: BreadcrumbsProps<T>): react.JSX.Element;
+interface BreadcrumbProps extends Omit<BreadcrumbProps$1, "className"> {
+    className?: string;
+}
+declare function Breadcrumb({ className, ...props }: BreadcrumbProps): react.JSX.Element;
+interface LinkProps extends Omit<LinkProps$1, "className"> {
+    children?: ReactNode;
+    className?: string;
+}
+declare function Link({ className, ...props }: LinkProps): react.JSX.Element;
+
+interface DisclosureProps extends Omit<DisclosureProps$1, "className" | "children"> {
+    /** Beschriftung des Triggers (Kopfzeile). */
+    title: ReactNode;
+    /** Inhalt des aufklappbaren Panels. */
+    children: ReactNode;
+    className?: string;
+}
+declare function Disclosure({ title, children, className, ...props }: DisclosureProps): react.JSX.Element;
+interface DisclosureGroupProps extends Omit<DisclosureGroupProps$1, "className"> {
+    className?: string;
+}
+declare function DisclosureGroup({ className, ...props }: DisclosureGroupProps): react.JSX.Element;
+
+interface TreeProps<T extends object> extends Omit<TreeProps$1<T>, "className"> {
+    className?: string;
+}
+declare function Tree<T extends object>({ className, ...props }: TreeProps<T>): react.JSX.Element;
+interface TreeItemProps extends Omit<TreeItemProps$1, "className" | "children" | "textValue"> {
+    /** Beschriftung der Zeile; dient zugleich als textValue für Typeahead. */
+    title: ReactNode;
+    /** Optionaler textValue, falls title kein reiner String ist. */
+    textValue?: string;
+    /** Verschachtelte TreeItems. */
+    children?: ReactNode;
+    className?: string;
+}
+declare function TreeItem({ title, textValue, children, className, ...props }: TreeItemProps): react.JSX.Element;
+
+interface TableProps extends Omit<TableProps$1, "className"> {
+    /** Header bleibt beim Scrollen oben kleben (Container muss eine feste Höhe haben). */
+    stickyHeader?: boolean;
+    className?: string;
+}
+declare function Table({ stickyHeader, className, ...props }: TableProps): react.JSX.Element;
+interface TableHeaderProps<T extends object> extends Omit<TableHeaderProps$1<T>, "className"> {
+    className?: string;
+}
+declare function TableHeader<T extends object>({ className, children, ...props }: TableHeaderProps<T>): react.JSX.Element;
+interface TableBodyProps<T extends object> extends Omit<TableBodyProps$1<T>, "className"> {
+    className?: string;
+}
+declare function TableBody<T extends object>({ className, ...props }: TableBodyProps<T>): react.JSX.Element;
+interface ColumnProps extends Omit<ColumnProps$1, "className" | "children"> {
+    children?: ReactNode;
+    className?: string;
+}
+declare function Column({ children, className, ...props }: ColumnProps): react.JSX.Element;
+interface RowProps<T extends object> extends Omit<RowProps$1<T>, "className"> {
+    className?: string;
+}
+declare function Row<T extends object>({ className, children, columns, ...props }: RowProps<T>): react.JSX.Element;
+interface CellProps extends Omit<CellProps$1, "className"> {
+    className?: string;
+}
+declare function Cell({ className, ...props }: CellProps): react.JSX.Element;
+
+interface DateFieldProps<T extends DateValue> extends Omit<DateFieldProps$1<T>, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    className?: string;
+}
+declare function DateField<T extends DateValue>({ label, description, errorMessage, className, ...props }: DateFieldProps<T>): react.JSX.Element;
+interface TimeFieldProps<T extends TimeValue> extends Omit<TimeFieldProps$1<T>, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    className?: string;
+}
+declare function TimeField<T extends TimeValue>({ label, description, errorMessage, className, ...props }: TimeFieldProps<T>): react.JSX.Element;
+
+interface CalendarProps<T extends DateValue> extends Omit<CalendarProps$1<T>, "className"> {
+    /** Optionale Fehlermeldung unterhalb des Gitters. */
+    errorMessage?: ReactNode;
+    className?: string;
+}
+declare function Calendar<T extends DateValue>({ errorMessage, className, ...props }: CalendarProps<T>): react.JSX.Element;
+interface RangeCalendarProps<T extends DateValue> extends Omit<RangeCalendarProps$1<T>, "className"> {
+    /** Optionale Fehlermeldung unterhalb des Gitters. */
+    errorMessage?: ReactNode;
+    className?: string;
+}
+declare function RangeCalendar<T extends DateValue>({ errorMessage, className, ...props }: RangeCalendarProps<T>): react.JSX.Element;
+
+interface DatePickerProps<T extends DateValue> extends Omit<DatePickerProps$1<T>, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    className?: string;
+}
+declare function DatePicker<T extends DateValue>({ label, description, errorMessage, className, ...props }: DatePickerProps<T>): react.JSX.Element;
+interface DateRangePickerProps<T extends DateValue> extends Omit<DateRangePickerProps$1<T>, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    className?: string;
+}
+declare function DateRangePicker<T extends DateValue>({ label, description, errorMessage, className, ...props }: DateRangePickerProps<T>): react.JSX.Element;
+
+interface ColorFieldProps extends Omit<ColorFieldProps$1, "className"> {
+    label?: ReactNode;
+    description?: ReactNode;
+    errorMessage?: ReactNode;
+    placeholder?: string;
+    className?: string;
+}
+declare function ColorField({ label, description, errorMessage, placeholder, className, ...props }: ColorFieldProps): react.JSX.Element;
+interface ColorSwatchProps extends Omit<ColorSwatchProps$1, "className"> {
+    className?: string;
+}
+declare function ColorSwatch({ className, ...props }: ColorSwatchProps): react.JSX.Element;
+interface ColorSwatchPickerProps extends Omit<ColorSwatchPickerProps$1, "className"> {
+    className?: string;
+}
+declare function ColorSwatchPicker({ className, children, ...props }: ColorSwatchPickerProps): react.JSX.Element;
+interface ColorSwatchPickerItemProps extends Omit<ColorSwatchPickerItemProps$1, "className"> {
+    className?: string;
+}
+declare function ColorSwatchPickerItem({ className, ...props }: ColorSwatchPickerItemProps): react.JSX.Element;
+
+interface ColorAreaProps extends Omit<ColorAreaProps$1, "className" | "children"> {
+    className?: string;
+}
+declare function ColorArea({ className, ...props }: ColorAreaProps): react.JSX.Element;
+interface ColorSliderProps extends Omit<ColorSliderProps$1, "className"> {
+    /** Beschriftung über dem Slider. */
+    label?: ReactNode;
+    /** Aktuellen Kanalwert rechts neben dem Label anzeigen. */
+    showValue?: boolean;
+    className?: string;
+}
+declare function ColorSlider({ label, showValue, className, ...props }: ColorSliderProps): react.JSX.Element;
+interface ColorWheelProps extends Omit<ColorWheelProps$1, "className" | "children" | "outerRadius" | "innerRadius"> {
+    /** Außenradius des Rings (Default 100). */
+    outerRadius?: number;
+    /** Innenradius des Rings (Default 74). */
+    innerRadius?: number;
+    className?: string;
+}
+declare function ColorWheel({ className, outerRadius, innerRadius, ...props }: ColorWheelProps): react.JSX.Element;
+interface ColorPickerProps extends Omit<ColorPickerProps$1, "children"> {
+    /** Beschriftung neben dem Farb-Swatch im Trigger. */
+    label?: ReactNode;
+    /** Eigene Inhalte des Popovers. Standard: ColorArea + Hue-Slider + ColorField. */
+    children?: ReactNode;
+    className?: string;
+}
+declare function ColorPicker({ label, children, className, ...props }: ColorPickerProps): react.JSX.Element;
+
+interface ProgressBarProps extends Omit<ProgressBarProps$1, "className" | "children"> {
+    /** Sichtbares Label oberhalb des Balkens. */
+    label?: ReactNode;
+    /** Formatierten Wert (z. B. „60 %") neben dem Label anzeigen. */
+    showValue?: boolean;
+    className?: string;
+}
+declare function ProgressBar({ label, showValue, className, ...props }: ProgressBarProps): react.JSX.Element;
+interface MeterProps extends Omit<MeterProps$1, "className" | "children"> {
+    /** Sichtbares Label oberhalb des Meters. */
+    label?: ReactNode;
+    /** Formatierten Wert neben dem Label anzeigen. */
+    showValue?: boolean;
+    /** Farbbänder nach Auslastung (grün/orange/rot) statt Akzentfarbe. */
+    bands?: boolean;
+    className?: string;
+}
+declare function Meter({ label, showValue, bands, className, ...props }: MeterProps): react.JSX.Element;
+interface SeparatorProps extends Omit<SeparatorProps$1, "className"> {
+    className?: string;
+}
+declare function Separator({ className, ...props }: SeparatorProps): react.JSX.Element;
+interface GroupProps extends Omit<GroupProps$1, "className"> {
+    className?: string;
+}
+declare function Group({ className, ...props }: GroupProps): react.JSX.Element;
+
+type ToastVariant = "default" | "success" | "warning" | "error";
+/** Struktur, die ein Prince-Toast anzeigt. */
+interface AplToast {
+    title: ReactNode;
+    description?: ReactNode;
+    variant?: ToastVariant;
+}
+/**
+ * Globale Toast-Queue. Konsumenten rufen `toastQueue.add({ title, ... })`,
+ * um einen Toast in der `<ToastRegion>` einzureihen.
+ */
+declare const toastQueue: UNSTABLE_ToastQueue<AplToast>;
+interface ToastRegionProps extends Omit<ToastRegionProps$1<AplToast>, "className" | "children" | "queue"> {
+    /** Eigene Queue (Standard: die exportierte `toastQueue`). */
+    queue?: UNSTABLE_ToastQueue<AplToast>;
+    className?: string;
+}
+/**
+ * Fixierte Region am unteren Rand, die eingereihte Toasts als erhöhte Karten
+ * mit Slide-in-Animation und Schließen-Button rendert.
+ */
+declare function ToastRegion({ queue, className, ...props }: ToastRegionProps): react.JSX.Element;
+
+interface DropZoneProps extends Omit<DropZoneProps$1, "className"> {
+    /** Inhalt der Dropzone, z. B. ein Prompt-Text und ein FileTrigger. */
+    children?: ReactNode;
+    className?: string;
+}
+declare function DropZone({ children, className, ...props }: DropZoneProps): react.JSX.Element;
+interface FileTriggerProps extends FileTriggerOwnProps {
+    /** Button-Beschriftung; Standard „Datei wählen". */
+    children?: ReactNode;
+    className?: string;
+}
+type FileTriggerOwnProps = Omit<FileTriggerProps$1, "children">;
+declare function FileTrigger({ children, className, ...props }: FileTriggerProps): react.JSX.Element;
+
+/** Einsatzort der Glasfläche — bestimmt Kanten, Radius und Schatten. */
+type GlassVariant = "bar" | "sidebar" | "overlay" | "card" | "floating";
+interface GlassSurfaceProps extends HTMLAttributes<HTMLElement> {
+    /** Wo die Fläche sitzt (Default: `"card"`). */
+    variant?: GlassVariant;
+    /** Optionaler Branding-Tint (rgba/hex), wird unter das Glas gelegt. */
+    tintColor?: string;
+    /** Gerendertes Element (Default: `"div"`). */
+    as?: ElementType;
+    children?: ReactNode;
+}
+/**
+ * GlassSurface — dünne „Liquid Glass"-Optik-Schicht (reines CSS, kein Verhalten).
+ *
+ * Sparsam und nur auf der „Navigationsebene" über dem Content einsetzen
+ * (Top-Bar, Sidebar, Overlays, schwebende Controls, Übersichtskarten).
+ * NICHT für datendichte Tabellen/Listen, Eingabefelder oder Fließtext —
+ * dort haben Lesbarkeit/Performance Vorrang. Glas nie stapeln.
+ *
+ * Der Effekt nutzt `backdrop-filter`; ohne Support oder bei
+ * `prefers-reduced-transparency` fällt die Fläche automatisch auf opak zurück.
+ */
+declare function GlassSurface({ variant, tintColor, as, className, style, children, ...rest }: GlassSurfaceProps): react.JSX.Element;
+
+/**
+ * prince-ui — Prince-Look React-Komponenten auf React Aria.
+ *
+ * Wave 1: L1-Primitives. CSS wird über die Bereichsmodule gebündelt
+ * (dist/index.css → Import via "@conuti-das/prince-ui/styles.css").
+ */
+declare const PRINCE_UI_VERSION = "0.8.0";
+/** Die drei Prince-Modes. `null` = System folgen (prefers-color-scheme, Fallback Dark). */
+type PrinceTheme = "light" | "dark" | "cu";
+/**
+ * Setzt das Theme am <html>-Element.
+ * - `"light"` / `"dark"` → Prince Light / Prince Dark (Apple-Optik: SF-Fonts, Apple-System-Farben, Grün)
+ * - `"cu"`               → CONUTI Community-Styling (CI-Grün)
+ * - `null`               → System folgen (Prince Light bei OS-Light, sonst Prince Dark)
+ */
+declare function setTheme(theme: PrinceTheme | null): void;
+/** Liest das aktuell erzwungene Theme oder `null`, wenn dem System gefolgt wird. */
+declare function getTheme(): PrinceTheme | null;
+
+export { type ActiveFilter, type AggregateType, Amount, type AmountProps, type AnalyticalColumn, AnalyticalTable, type AnalyticalTableProps, type AplPopoverProps, type AplToast, AppShell, type AppShellItem, type AppShellMenuItem, type AppShellProps, AreaChart, type AreaChartProps, Badge, type BadgeProps, type BadgeTone, BarChart, type BarChartProps, type BarDatum, type BeforeNavigateDetail, Breadcrumb, type BreadcrumbProps, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, Calendar, type CalendarProps, Card, type CardProps, Cell, type CellProps, ChartEmpty, type ChartEmptyProps, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, ColorArea, type ColorAreaProps, ColorField, type ColorFieldProps, ColorPicker, type ColorPickerProps, ColorSlider, type ColorSliderProps, ColorSwatch, ColorSwatchPicker, ColorSwatchPickerItem, type ColorSwatchPickerItemProps, type ColorSwatchPickerProps, type ColorSwatchProps, ColorWheel, type ColorWheelProps, Column, type ColumnFilterType, type ColumnProps, ComboBox, ComboBoxItem, type ComboBoxItemProps, type ComboBoxProps, DateField, type DateFieldProps, DatePicker, type DatePickerProps, DateRangePicker, type DateRangePickerProps, DescriptionList, type DescriptionListProps, Disclosure, DisclosureGroup, type DisclosureGroupProps, type DisclosureProps, DonutChart, type DonutChartProps, type DonutSegment, DropZone, type DropZoneProps, EmptyState, type EmptyStateProps, Field, FieldError, type FieldErrorProps, type FieldProps, FileTrigger, type FileTriggerProps, FilterBar, type FilterBarProps, FilterField, type FilterFieldProps, Form, type FormProps, GlassSurface, type GlassSurfaceProps, type GlassVariant, GridList, GridListItem, type GridListItemProps, type GridListProps, Group, type GroupProps, Icon, type IconName, type IconProps, KpiCard, type KpiCardProps, type KpiTone, Launchpad, type LaunchpadCard, type LaunchpadProps, type LaunchpadSection, type LaunchpadSpan, Link, type LinkProps, List, ListBox, ListBoxOption, type ListBoxOptionProps, type ListBoxProps, type ListProps, ListRow, type ListRowProps, type LpCustomCard, type LpKpiCard, type LpListCard, type LpListRowModel, type LpNavCard, type LpTrendCard, Menu, MenuItem, type MenuItemPropsExt, type MenuProps, Meter, type MeterProps, Modal, type ModalProps, type NoDataReason, Notice, type NoticeProps, type NoticeTone, NumberField, type NumberFieldProps, type ObjectField, ObjectPage, type ObjectPageAccessibilityAttributes, type ObjectPageHandle, type ObjectPageKpi, type ObjectPageMode, type ObjectPageProps, ObjectPageSection, type ObjectPageSectionProps, ObjectPageSubSection, type ObjectPageSubSectionProps, type ObjectSection, PRINCE_UI_VERSION, Popover, type PrinceTheme, ProgressBar, type ProgressBarProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, RangeCalendar, type RangeCalendarProps, Row, type RowProps, type ScaleWidthMode, SearchField, type SearchFieldProps, Segment, type SegmentProps, SegmentedControl, type SegmentedControlProps, Select, SelectItem, type SelectItemProps, type SelectProps, type SelectedSectionChangeDetail, type SelectionBehavior, type SelectionMode, Separator, type SeparatorProps, Sidebar, type SidebarGroup, type SidebarItem, type SidebarProps, Slider, type SliderProps, type SortType, Sparkline, type SparklineProps, type StatusBadge, type StatusTone, type SubComponentsBehavior, Switch, type SwitchProps, Tab, TabBar, TabPanel, Table, TableBody, type TableBodyProps, TableHeader, type TableHeaderProps, type TableProps, Tabs, type TabsProps, Tag, TagGroup, type TagGroupProps, type TagProps, TextField, type TextFieldProps, TimeField, type TimeFieldProps, type TitleTextLevel, ToastRegion, type ToastRegionProps, type ToastVariant, Toolbar, type ToolbarProps, Tooltip, type TooltipProps, Tree, TreeItem, type TreeItemProps, type TreeProps, type Trend$1 as Trend, type UseFilterStateOptions, type UseFilterStateResult, type ValueState, type VisibleRowCountMode, cx, getTheme, setTheme, smoothPath, toastQueue, useFilterState };