@karni/ui 0.0.0-stage → 0.3.1

package/dist/src/auth/usePermission.d.ts

@@ -0,0 +1,7 @@
+export interface PermissionHelpers {
+    /** True when the user has at least one of the given role names. */
+    hasRole(...names: string[]): boolean;
+    isAuthenticated: boolean;
+}
+/** `isAuthenticated` and `hasRole(...names)` for the signed-in user. */
+export declare function usePermission(): PermissionHelpers;

package/dist/src/components/brand/karni-mark.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+export interface KarniMarkProps extends Omit<React.SVGAttributes<SVGSVGElement>, "children"> {
+    /** Rendered size in px (width and height). Default 28. */
+    size?: number;
+    /**
+     * Which drawing: the full mark, the small-size variant, or `auto` (the
+     * default) — the small variant at 32px and below, the full mark above.
+     */
+    variant?: "auto" | "full" | "simple";
+    /** Accessible name; pass an empty string to hide a purely decorative mark. */
+    title?: string;
+}
+/**
+ * The Karni mark, inline SVG — no asset to load or bundle.
+ *
+ * It is the default content of `<Layout>`'s `sidebarHeader` slot so a bare
+ * shell is never nameless; a project replaces it by passing its own
+ * `sidebarHeader` (the scaffold already does). Do not recolour or restyle it:
+ * the mark is Karni's, see assets/brand/README.md in the repository.
+ */
+export declare const KarniMark: React.ForwardRefExoticComponent<KarniMarkProps & React.RefAttributes<SVGSVGElement>>;

package/dist/src/components/brand/mark-paths.d.ts

@@ -0,0 +1,8 @@
+export declare const MARK_VIEWBOX = "0 0 1000 1000";
+/** The full mark: ground, rings, strokes. */
+export declare const MARK_PATHS: ReadonlyArray<{
+    readonly fill: string;
+    readonly d: string;
+}>;
+/** The small-size variant's SVG body (use at 32px and below). */
+export declare const MARK_SIMPLE_BODY = "<path fill=\"#000000\" d=\"M495.8 884.4C291.9 874.2 135.4 724 114.7 518.5C97.9 351.3 160.2 221 290.9 150.2C372.3 106.1 439.7 86.4 513.6 85.2C686 82.3 812.9 171.5 867 333.5C903.9 444 890.2 573.8 828.6 698.6C766.8 823.4 644.3 891.8 495.8 884.4Z\"/>\n<circle cx=\"340\" cy=\"300\" r=\"44\" fill=\"#FB5D08\"/>\n<circle cx=\"500\" cy=\"276\" r=\"44\" fill=\"#FB5D08\"/>\n<circle cx=\"660\" cy=\"300\" r=\"44\" fill=\"#FB5D08\"/>\n<path fill=\"none\" stroke=\"#FFFFFF\" stroke-width=\"58\" stroke-linecap=\"round\" stroke-linejoin=\"round\"\n      d=\"M318 420v280l182-250 182 250V420M500 450 410 700M500 450l90 250\"/>";

package/dist/src/components/chart/data-chart.d.ts

@@ -0,0 +1,74 @@
+import * as React from "react";
+/**
+ * In-house SVG chart (contract: no chart dependency).
+ *
+ * Accessibility model (contract D10): the SVG is a labelled image
+ * (role="img" + aria-label + <title>/<desc>); the REAL accessible data
+ * surface is a visually-hidden <table> rendered next to it. The hover
+ * tooltip is a visual-only affordance rendered OUTSIDE the role="img"
+ * element and hidden from assistive tech.
+ *
+ * Colors come exclusively from the --karni-chart-1..5 tokens, via the
+ * Tailwind preset's chart color scale (stroke-chart-N / fill-chart-N /
+ * bg-chart-N classes — whole class names, per contract D7).
+ */
+export type DataChartKind = "line" | "bar";
+export interface DataChartPoint {
+    label: string;
+    value: number;
+}
+export interface DataChartSeries {
+    name: string;
+    data: readonly DataChartPoint[];
+}
+export interface DataChartTooltipContext {
+    /** Category (x-axis) label under the pointer. */
+    label: string;
+    /** One entry per series that has a value at this category. */
+    points: ReadonlyArray<{
+        seriesName: string;
+        value: number;
+        swatchClassName: string;
+    }>;
+}
+export interface DataChartProps {
+    kind: DataChartKind;
+    /** Single-series shorthand (ignored when `series` is given). */
+    data?: readonly DataChartPoint[];
+    /** Multi-series data; series cycle through --karni-chart-1..5. */
+    series?: readonly DataChartSeries[];
+    /** Chart title: SVG <title>, aria-label and the hidden table's caption. */
+    title: string;
+    /** Longer description for the SVG <desc>. */
+    description?: string;
+    /** Formats values in the tooltip, y-axis ticks and the hidden table. */
+    valueFormatter?: (value: number) => string;
+    /** Formats x-axis tick labels (default: the category label itself). */
+    xTickFormatter?: (label: string) => string;
+    /** Escape hatch: fully custom tooltip content. */
+    renderTooltip?: (context: DataChartTooltipContext) => React.ReactNode;
+    /** viewBox width (default 640) — rendered size is responsive. */
+    width?: number;
+    /** viewBox height (default 240). */
+    height?: number;
+    /** Approximate number of y-axis ticks (default 4). */
+    yTickCount?: number;
+    /** Show the series legend (default: only for 2+ series). */
+    showLegend?: boolean;
+    /** Show the hover tooltip (default true). */
+    showTooltip?: boolean;
+    /** Column header of the hidden table's category column (default "Label"). */
+    categoryHeader?: string;
+    /** Text shown when there is no plottable data. */
+    emptyLabel?: string;
+    className?: string;
+}
+/**
+ * Minimal line/bar chart driven by `{label, value}` points or named series.
+ *
+ * Escape hatches: `valueFormatter`/`xTickFormatter`, `renderTooltip`,
+ * `width`/`height`/`yTickCount`, legend and tooltip toggles, `className`
+ * (merged via cn()). Colors are only themeable through the
+ * --karni-chart-1..5 CSS variables.
+ */
+export declare function DataChart({ kind, data, series, title, description, valueFormatter, xTickFormatter, renderTooltip, width, height, yTickCount, showLegend, showTooltip, categoryHeader, emptyLabel, className, }: DataChartProps): React.ReactElement;

package/dist/src/components/empty-state/empty-state.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Optional illustration/icon slot, rendered above the title. */
+    icon?: React.ReactNode;
+    /** Short headline ("No events yet"). */
+    title: React.ReactNode;
+    /** Optional supporting copy under the title. */
+    description?: React.ReactNode;
+    /** Slot for a call to action (e.g. a "Create" button). */
+    action?: React.ReactNode;
+    children?: React.ReactNode;
+}
+/**
+ * Centered placeholder for empty collections: icon, title, description and
+ * an action slot. Used by ResourceTable's `empty` slot and reusable anywhere.
+ *
+ * Escape hatches: every visual part is a slot; `className` merges via cn();
+ * extra children render under the action.
+ */
+export declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/file-upload/FileUpload.d.ts

@@ -0,0 +1,44 @@
+import * as React from "react";
+/** Why a file was refused by <FileUpload> (surfaced through `onReject`). */
+export type FileUploadRejectReason = "accept" | "size";
+export interface FileUploadProps {
+    /**
+     * Current value. A `string` is an existing uploaded file (the display URL a
+     * karni backend returns); a `File` is a pending upload. Arrays are for
+     * `multiple` mode and may mix both.
+     */
+    value?: File | string | ReadonlyArray<File | string> | null;
+    /**
+     * Emits the newly chosen `File` (or `File[]` when `multiple`), and `null`
+     * when the value is cleared. Existing URL strings are display-only: they
+     * can be removed (emitting `null` / the remaining files) but never re-emitted.
+     */
+    onChange?: (value: File | File[] | null) => void;
+    /** Same grammar as the native `accept` attribute (".png,image/*,application/pdf"). */
+    accept?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    /** Maximum size per file, in bytes. Larger files are rejected via `onReject`. */
+    maxSize?: number;
+    /** Called once per refused file with the reason ("accept" | "size"). */
+    onReject?: (file: File, reason: FileUploadRejectReason) => void;
+    id?: string;
+    /** Forwarded to the hidden native file input. */
+    name?: string;
+    className?: string;
+    /** Replaces the default dropzone content (escape hatch). */
+    children?: React.ReactNode;
+    /** Set false to hide the per-file remove affordance. Default true. */
+    clearable?: boolean;
+    "aria-label"?: string;
+}
+/**
+ * Drag-and-drop or click-to-browse file picker that shows the current file and the pending ones.
+ *
+ * Contract "FileUpload".
+ *
+ * Shows an existing uploaded value (URL string) as a link, pending `File`
+ * values with name and size, and emits `File` objects — the hooks layer turns
+ * them into multipart bodies per amendment D2.
+ */
+export declare function FileUpload(props: FileUploadProps): React.ReactElement;

package/dist/src/components/layout/layout.d.ts

@@ -0,0 +1,55 @@
+import * as React from "react";
+export interface LayoutNavItem {
+    /** Visible label of the nav entry. */
+    label: React.ReactNode;
+    /** Target URL (rendered as a plain <a> by default). */
+    href: string;
+    /** Optional icon rendered before the label. */
+    icon?: React.ReactNode;
+    /** Marks the current page (aria-current="page" + active styling). */
+    active?: boolean;
+    /** React key override when `href` is not unique. */
+    key?: string;
+}
+export interface LayoutProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Items of the derived sidebar nav. */
+    navItems?: readonly LayoutNavItem[];
+    /**
+     * Escape hatch for router integration: wraps/replaces the default anchor of
+     * one item. `defaultNode` is the styled <a> the layout would render — return
+     * it, or your own node (e.g. a TanStack Router <Link> with
+     * `className={defaultClassName}`).
+     */
+    renderNavItem?: (item: LayoutNavItem, defaults: {
+        defaultNode: React.ReactNode;
+        defaultClassName: string;
+    }) => React.ReactNode;
+    /** Escape hatch: replaces the entire derived nav inside the sidebar. */
+    sidebar?: React.ReactNode;
+    /**
+     * Brand/logo slot pinned to the top of the sidebar. Defaults to the Karni
+     * mark (`<KarniMark />`); pass your own brand, or `null` for no header.
+     */
+    sidebarHeader?: React.ReactNode;
+    /** Slot pinned to the bottom of the sidebar (user menu, logout, …). */
+    sidebarFooter?: React.ReactNode;
+    /** Header slot, rendered in the top bar next to the mobile menu button. */
+    header?: React.ReactNode;
+    /** Accessible name of the sidebar navigation (default "Main"). */
+    navLabel?: string;
+    sidebarClassName?: string;
+    headerClassName?: string;
+    contentClassName?: string;
+    children?: React.ReactNode;
+}
+/**
+ * App shell: sidebar navigation + header slot + content area.
+ *
+ * Responsive: under the `md` breakpoint the sidebar collapses behind a menu
+ * button and opens as an overlay drawer (Escape or backdrop click closes it).
+ *
+ * Escape hatches: `renderNavItem` wraps each derived link (router
+ * integration), `sidebar` replaces the derived nav wholesale, and
+ * `sidebarHeader`/`sidebarFooter`/`header` are free slots.
+ */
+export declare const Layout: React.ForwardRefExoticComponent<LayoutProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/modal/modal.d.ts

@@ -0,0 +1,45 @@
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+import * as React from "react";
+/**
+ * Escape hatch for footer buttons: any element wrapped in <ModalClose asChild>
+ * closes the modal on click (re-exported Radix Dialog.Close).
+ */
+export declare const ModalClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+export interface ModalProps {
+    /** Dialog title — always rendered (Radix requires it for accessibility). */
+    title: React.ReactNode;
+    /** Optional description under the title, linked via aria-describedby. */
+    description?: React.ReactNode;
+    /** Body content. */
+    children?: React.ReactNode;
+    /** Footer slot (actions row). Use <ModalClose asChild> for cancel buttons. */
+    footer?: React.ReactNode;
+    /**
+     * Uncontrolled usage: a node (usually a Button) that opens the modal,
+     * rendered through Radix `asChild`.
+     */
+    trigger?: React.ReactNode;
+    /** Controlled open state (pair with onOpenChange). */
+    open?: boolean;
+    /** Initial state for uncontrolled usage. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Hides the top-right X button. */
+    hideCloseButton?: boolean;
+    /** Extra classes for the content panel. */
+    className?: string;
+    /**
+     * Escape hatch: props spread onto Radix Dialog.Content
+     * (onEscapeKeyDown, onInteractOutside, …).
+     */
+    contentProps?: Omit<React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, "children" | "className">;
+}
+/**
+ * Themed Radix Dialog. Works controlled (`open` + `onOpenChange`) or
+ * uncontrolled via the `trigger` slot; `footer` is the actions row.
+ *
+ * Escape hatches: `contentProps` reaches the Radix content part, `className`
+ * restyles the panel, `hideCloseButton` drops the X, and `ModalClose` lets any
+ * footer element close the dialog.
+ */
+export declare function Modal({ title, description, children, footer, trigger, open, defaultOpen, onOpenChange, hideCloseButton, className, contentProps, }: ModalProps): React.ReactElement;

package/dist/src/components/page/page.d.ts

@@ -0,0 +1,29 @@
+import * as React from "react";
+export interface PageProps extends Omit<React.HTMLAttributes<HTMLElement>, "title"> {
+    /** Page heading, rendered as an <h1>. */
+    title: React.ReactNode;
+    /** Optional sub-heading under the title. */
+    description?: React.ReactNode;
+    /** Slot rendered to the right of the title (buttons, menus, …). */
+    actions?: React.ReactNode;
+    /**
+     * Escape hatch: replaces the entire derived header (title/description/
+     * actions are ignored when given).
+     */
+    header?: React.ReactNode;
+    /** Extra classes for the derived header row. */
+    headerClassName?: string;
+    /** Extra classes for the content area under the header. */
+    contentClassName?: string;
+    children?: React.ReactNode;
+}
+/**
+ * Standard page chrome: an <h1> title row with an actions slot, then the
+ * content. The target usage `<Page title="Events"><ResourceTable … /></Page>`
+ * is a complete screen.
+ *
+ * Escape hatches: `header` replaces the whole derived header; `className`,
+ * `headerClassName` and `contentClassName` merge through cn(); every other
+ * prop passes through to the root <section>.
+ */
+export declare const Page: React.ForwardRefExoticComponent<PageProps & React.RefAttributes<HTMLElement>>;

package/dist/src/components/primitives/button.d.ts

@@ -0,0 +1,44 @@
+import { VariantProps } from '../../lib/variants';
+import * as React from "react";
+/**
+ * Exported for composition (escape hatch): render any element as a button
+ * lookalike with `className={buttonVariants({ variant: "outline" })}`.
+ */
+export declare const buttonVariants: import('../..').VariantFn<{
+    variant: {
+        default: string;
+        destructive: string;
+        outline: string;
+        secondary: string;
+        ghost: string;
+        link: string;
+    };
+    size: {
+        default: string;
+        sm: string;
+        lg: string;
+        icon: string;
+    };
+}>;
+export type ButtonVariantProps = VariantProps<typeof buttonVariants>;
+export type ButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement> & ButtonVariantProps;
+/**
+ * Themed button. `type` defaults to "button" (pass type="submit" in forms).
+ * `className` is merged via cn(), so consumer classes win.
+ */
+export declare const Button: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & import('../..').VariantSelection<{
+    variant: {
+        default: string;
+        destructive: string;
+        outline: string;
+        secondary: string;
+        ghost: string;
+        link: string;
+    };
+    size: {
+        default: string;
+        sm: string;
+        lg: string;
+        icon: string;
+    };
+}> & React.RefAttributes<HTMLButtonElement>>;

package/dist/src/components/primitives/checkbox.d.ts

@@ -0,0 +1,5 @@
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import * as React from "react";
+export type CheckboxProps = React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>;
+/** Themed checkbox (Radix Checkbox) with a check mark indicator. */
+export declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/src/components/primitives/dropdown-menu.d.ts

@@ -0,0 +1,24 @@
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import * as React from "react";
+/** Dropdown menu root (Radix DropdownMenu). */
+export declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+/** The element that opens the menu. */
+export declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+/** Groups related menu items. */
+export declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+/** Renders the menu into `document.body`. */
+export declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+/** The styled menu panel. */
+export declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** One menu item; `onSelect` runs the action. */
+export declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/** A menu item with a check mark that toggles `checked`. */
+export declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** A non-interactive heading inside the menu. */
+export declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+/** A divider line between menu items. */
+export declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/primitives/icons.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+/**
+ * Minimal inline SVG icons used by the primitives (no icon dependency).
+ * All strokes use `currentColor`, so they follow the text color tokens.
+ * Internal to @karni/ui — not part of the public barrel.
+ */
+type IconProps = React.SVGAttributes<SVGSVGElement>;
+export declare function CheckIcon(props: IconProps): React.ReactElement;
+export declare function ChevronDownIcon(props: IconProps): React.ReactElement;
+export declare function ChevronUpIcon(props: IconProps): React.ReactElement;
+export {};

package/dist/src/components/primitives/input.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+export type InputProps = React.InputHTMLAttributes<HTMLInputElement>;
+/** Themed text input; every native `<input>` prop passes through. */
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/src/components/primitives/label.d.ts

@@ -0,0 +1,5 @@
+import * as LabelPrimitive from "@radix-ui/react-label";
+import * as React from "react";
+export type LabelProps = React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>;
+/** Themed form label (Radix Label) that dims when its field is disabled. */
+export declare const Label: React.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React.RefAttributes<HTMLLabelElement>, "ref"> & React.RefAttributes<HTMLLabelElement>>;

package/dist/src/components/primitives/select.d.ts

@@ -0,0 +1,63 @@
+import * as SelectPrimitive from "@radix-ui/react-select";
+import * as React from "react";
+/**
+ * The value that stands for "nothing selected" inside Radix Select, which reserves the empty string.
+ *
+ * This package maps the empty state through this sentinel at the component boundary (contract D8). Consumers of
+ * the composed <Select> never see it: `value`/`onValueChange` use `null`.
+ */
+export declare const KARNI_SELECT_EMPTY = "__karni_empty__";
+/** Radix Select root, for composing a custom select from the styled parts. */
+export declare const SelectRoot: React.FC<SelectPrimitive.SelectProps>;
+/** Groups related options inside `SelectContent`. */
+export declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+/** Shows the selected option's label inside `SelectTrigger`. */
+export declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+/** The styled button that opens the select. */
+export declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/** The styled dropdown panel that lists the options. */
+export declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** A heading inside a `SelectGroup`. */
+export declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** One selectable option; `value` is what the select reports. */
+export declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** A divider line between option groups. */
+export declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface SelectOption {
+    /** Must be non-empty and not the reserved sentinel. */
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+}
+export interface SelectProps {
+    /** `null`/`""`/`undefined` all mean "no selection". */
+    value: string | null | undefined;
+    /** Receives `null` when the clear item is chosen, else the option value. */
+    onValueChange?: (value: string | null) => void;
+    options: readonly SelectOption[];
+    placeholder?: React.ReactNode;
+    /**
+     * Renders a clear item at the top of the list (contract D8): pass it for
+     * nullable fields (label "—" by default) and filter contexts (e.g. "All").
+     * Choosing it emits `null`.
+     */
+    clearable?: boolean;
+    clearLabel?: React.ReactNode;
+    disabled?: boolean;
+    /** Forwarded to the hidden native select for HTML form submission. */
+    name?: string;
+    id?: string;
+    /** Merged onto the trigger. */
+    className?: string;
+    contentClassName?: string;
+    "aria-label"?: string;
+    /** Extra <SelectItem>/<SelectGroup> nodes appended after `options` (escape hatch). */
+    children?: React.ReactNode;
+}
+/**
+ * Styled select for a list of `options`, with `null` for no selection. Maps the
+ * empty state through the KARNI_SELECT_EMPTY sentinel so `""` never reaches
+ * Radix (D8). For fully custom composition use SelectRoot/SelectTrigger/
+ * SelectContent/SelectItem directly.
+ */
+export declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/src/components/primitives/skeleton.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+export type SkeletonProps = React.HTMLAttributes<HTMLDivElement>;
+/** Loading placeholder block; size it with width/height utility classes. */
+export declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/primitives/switch.d.ts

@@ -0,0 +1,5 @@
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+import * as React from "react";
+export type SwitchProps = React.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root>;
+/** Themed on/off toggle (Radix Switch). */
+export declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;

package/dist/src/components/primitives/tabs.d.ts

@@ -0,0 +1,10 @@
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import * as React from "react";
+/** Tab set root (Radix Tabs); holds the selected value. */
+export declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+/** The row of tab buttons. */
+export declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/** One tab button; `value` names the panel it opens. */
+export declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+/** The panel shown while its `value` is the selected tab. */
+export declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/primitives/textarea.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+export type TextareaProps = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+/** Themed multi-line text input; every native `<textarea>` prop passes through. */
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;

package/dist/src/components/resource/ResourceDetail.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel-facing path for <ResourceDetail>. The implementation lives in
+ * ./detail/ (resource form builder); every contract-pinned export name is
+ * re-exported here so src/index.ts keeps resolving this module.
+ */
+export { ResourceDetail } from './detail/ResourceDetail';
+export type { ResourceDetailProps, ResourceDetailFieldOverride } from './detail/ResourceDetail';

package/dist/src/components/resource/ResourceForm.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel-facing path for <ResourceForm>. The implementation lives in
+ * ./form/ (resource form builder); every contract-pinned export name is
+ * re-exported here so src/index.ts keeps resolving this module.
+ */
+export { ResourceForm } from './form/ResourceForm';
+export type { ResourceFormProps, FieldOverride, KarniFieldProps } from './form/ResourceForm';

package/dist/src/components/resource/ResourceSelect.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Barrel-facing path for <ResourceSelect>. The implementation lives in
+ * ./select/ (resource form builder); every contract-pinned export name is
+ * re-exported here so src/index.ts keeps resolving this module.
+ */
+export { ResourceSelect } from './select/ResourceSelect';
+export type { ResourceSelectProps } from './select/ResourceSelect';

package/dist/src/components/resource/ResourceTable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public entry for ResourceTable (owner: resource table builder).
+ *
+ * The implementation lives in ./table/ (ResourceTable + filter bar +
+ * pagination controls + bulk select, contract "ResourceTable" + D5); this
+ * module keeps the barrel's import path and exported names stable.
+ */
+export { ResourceTable } from './table/ResourceTable';
+export type { ResourceTableProps } from './table/ResourceTable';
+export type { ResourceColumn } from './table/derive-columns';
+export type { BulkAction } from './table/BulkActionsBar';

package/dist/src/components/resource/audit-fields.d.ts

@@ -0,0 +1,17 @@
+import { FieldDef } from '../../schema/types';
+/** The audit field names (`created_at`, `created_by`, …) that tables hide and detail views group last. */
+export declare const AUDIT_FIELDS: readonly string[];
+/**
+ * True for a schema field that is one of AUDIT_FIELDS. The backend always
+ * emits these readOnly; a writable field that merely shares a name (a natural
+ * `id` key, say) is domain data and is never treated as audit.
+ */
+export declare function isAuditField(field: Pick<FieldDef, "name" | "readOnly">): boolean;
+/**
+ * Splits fields into domain fields (schema order kept) and audit fields
+ * (AUDIT_FIELDS order).
+ */
+export declare function partitionAuditFields<F extends Pick<FieldDef, "name" | "readOnly">>(fields: readonly F[]): {
+    domain: F[];
+    audit: F[];
+};

package/dist/src/components/resource/detail/ResourceDetail.d.ts

@@ -0,0 +1,30 @@
+import * as React from "react";
+export interface ResourceDetailFieldOverride {
+    label?: string;
+    hidden?: boolean;
+    render?: (value: unknown, item: Record<string, unknown>) => React.ReactNode;
+}
+export interface ResourceDetailProps {
+    resource: string;
+    id: string | number;
+    fields?: Record<string, ResourceDetailFieldOverride>;
+    /** Appended below the field list (e.g. a child <ResourceTable>). */
+    sections?: ReadonlyArray<React.ReactNode>;
+    expand?: readonly string[];
+    title?: React.ReactNode;
+    actions?: React.ReactNode;
+    className?: string;
+}
+/**
+ * Schema-driven read view of one row: every readable field, labelled and formatted.
+ *
+ * Contract "ResourceDetail": a definition list of
+ * every non-writeOnly field — domain fields first (schema order), then the
+ * audit fields (AUDIT_FIELDS: id, created_at, updated_at, created_by,
+ * updated_by) in a visually muted "Record" group. Relations render through
+ * displayLabel when the object is expanded (the field is in `expand`), else
+ * as the raw id in <code>. Escape hatches: per-field `fields` overrides
+ * (label/hidden/render — audit fields included), appended `sections`, and the
+ * title/actions header slots.
+ */
+export declare function ResourceDetail(props: ResourceDetailProps): React.ReactElement;

package/dist/src/components/resource/displayLabel.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Human label heuristic for resource objects (contract "ResourceTable").
+ *
+ * Used by ResourceTable's relation cells, ResourceSelect's options and
+ * ResourceDetail's relation values. Overridable everywhere it is used:
+ * ResourceTable takes `getRowLabel`, ResourceSelect takes `getOptionLabel`.
+ */
+/**
+ * Returns the first non-empty string among the `name` → `title` → `label` →
+ * `email` → `str` keys, falling back to `String(id)` and finally "".
+ */
+export declare function displayLabel(obj: Record<string, unknown>): string;